From aeaf220ce3d8a87c6e42639f6ba8e0d679711f9d Mon Sep 17 00:00:00 2001 From: Jomy10 Date: Tue, 12 Sep 2023 19:38:37 +0200 Subject: [PATCH 1/7] initial Zig 12 support --- Sdk.zig | 63 ++++++++++++++++++++++--------------------- build/auto-detect.zig | 34 ++++++++++++----------- strings.xml | 0 3 files changed, 50 insertions(+), 47 deletions(-) create mode 100644 strings.xml diff --git a/Sdk.zig b/Sdk.zig index 29f59f9..a54bcfa 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -18,11 +18,9 @@ fn sdkRoot() *const [sdkRootIntern().len]u8 { // linux-x86_64 pub fn toolchainHostTag() []const u8 { - comptime { - const os = builtin.os.tag; - const arch = builtin.cpu.arch; - return @tagName(os) ++ "-" ++ @tagName(arch); - } + const os = builtin.os.tag; + const arch = builtin.cpu.arch; + return (comptime if (std.mem.eql(u8, @tagName(os), "macos")) "darwin" else @tagName(os)) ++ "-" ++ @tagName(arch); } /// This file encodes a instance of an Android SDK interface. @@ -92,12 +90,12 @@ pub fn init(b: *Builder, user_config: ?UserConfig, toolchains: ToolchainVersions .name = "zip_add", .root_source_file = .{ .path = sdkRoot() ++ "/tools/zip_add.zig" }, }); - zip_add.addCSourceFile(sdkRoot() ++ "/vendor/kuba-zip/zip.c", &[_][]const u8{ + zip_add.addCSourceFile(.{ .file = .{ .path = sdkRoot() ++ "/vendor/kuba-zip/zip.c" }, .flags = &[_][]const u8{ "-std=c99", "-fno-sanitize=undefined", "-D_POSIX_C_SOURCE=200112L", - }); - zip_add.addIncludePath(sdkRoot() ++ "/vendor/kuba-zip"); + } }); + zip_add.addIncludePath(.{ .path = sdkRoot() ++ "/vendor/kuba-zip" }); zip_add.linkLibC(); break :blk HostTools{ @@ -503,10 +501,11 @@ pub fn createApp( } resource_dir_step.add(Resource{ .path = "values/strings.xml", - .content = write_xml_step.getFileSource("strings.xml").?, + // .content = write_xml_step.getFileSource("strings.xml").?, + .content = write_xml_step.addCopyFile(.{ .path = "strings.xml" }, ""), }); - const sdk_version_int = @enumToInt(app_config.target_version); + const sdk_version_int = @intFromEnum(app_config.target_version); if (sdk_version_int < 16) @panic("Minimum supported sdk version is 16."); @@ -549,7 +548,8 @@ pub fn createApp( const unaligned_apk_file = make_unsigned_apk.addOutputFileArg(unaligned_apk_name); make_unsigned_apk.addArg("-M"); // specify full path to AndroidManifest.xml to include in zip - make_unsigned_apk.addFileSourceArg(manifest_step.getFileSource("AndroidManifest.xml").?); + // make_unsigned_apk.addFileSourceArg(manifest_step.getFileSource("AndroidManifest.xml").?); + make_unsigned_apk.addFileSourceArg(manifest_step.addCopyFile(.{ .path = "AndroidManifest.xml" }, "")); make_unsigned_apk.addArg("-S"); // directory in which to find resources. Multiple directories will be scanned and the first match found (left to right) will take precedence make_unsigned_apk.addDirectorySourceArg(resource_dir_step.getOutputDirectory()); @@ -848,7 +848,7 @@ pub fn compileAppLibrary( ndk_root, toolchainHostTag(), config.lib_dir, - @enumToInt(app_config.target_version), + @intFromEnum(app_config.target_version), }); const include_dir = std.fs.path.resolve(sdk.b.allocator, &[_][]const u8{ @@ -887,7 +887,7 @@ pub fn compileAppLibrary( // exe.addIncludePath(include_dir); - exe.addLibraryPath(lib_dir); + exe.addLibraryPath(.{ .path = lib_dir }); // exe.addIncludePath(include_dir); // exe.addIncludePath(system_include_dir); @@ -904,7 +904,7 @@ pub fn compileAppLibrary( } fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const u8, include_dir: []const u8, sys_include_dir: []const u8, crt_dir: []const u8) !std.build.FileSource { - const fname = sdk.b.fmt("android-{d}-{s}.conf", .{ @enumToInt(version), folder_name }); + const fname = sdk.b.fmt("android-{d}-{s}.conf", .{ @intFromEnum(version), folder_name }); var contents = std.ArrayList(u8).init(sdk.b.allocator); errdefer contents.deinit(); @@ -926,7 +926,8 @@ fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const try writer.writeAll("gcc_dir=\n"); const step = sdk.b.addWriteFile(fname, contents.items); - return step.getFileSource(fname) orelse unreachable; + // return step.getFileSource(fname) orelse unreachable; + return step.addCopyFile(.{ .path = fname }, ""); } pub fn compressApk(sdk: Sdk, input_apk_file: []const u8, output_apk_file: []const u8) *Step { @@ -1151,22 +1152,22 @@ const BuildOptionStep = struct { } return; }, - std.builtin.Version => { - out.print( - \\pub const {}: @import("std").builtin.Version = .{{ - \\ .major = {d}, - \\ .minor = {d}, - \\ .patch = {d}, - \\}}; - \\ - , .{ - std.zig.fmtId(name), - - value.major, - value.minor, - value.patch, - }) catch unreachable; - }, + // std.builtin.Version => { + // out.print( + // \\pub const {}: @import("std").builtin.Version = .{{ + // \\ .major = {d}, + // \\ .minor = {d}, + // \\ .patch = {d}, + // \\}}; + // \\ + // , .{ + // std.zig.fmtId(name), + + // value.major, + // value.minor, + // value.patch, + // }) catch unreachable; + // }, std.SemanticVersion => { out.print( \\pub const {}: @import("std").SemanticVersion = .{{ diff --git a/build/auto-detect.zig b/build/auto-detect.zig index dfe0351..6b83097 100644 --- a/build/auto-detect.zig +++ b/build/auto-detect.zig @@ -24,17 +24,19 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig // Check for a user config file. if (std.fs.cwd().openFile(config_path, .{})) |file| { defer file.close(); - const bytes = file.readToEndAlloc(b.allocator, 1 * 1000 * 1000) catch |err| { - print("Unexpected error reading {s}: {s}\n", .{ config_path, @errorName(err) }); - return err; - }; - var stream = std.json.TokenStream.init(bytes); - if (std.json.parse(UserConfig, &stream, .{ .allocator = b.allocator })) |conf| { - config = conf; - } else |err| { - print("Could not parse {s} ({s}).\n", .{ config_path, @errorName(err) }); - return err; - } + // @panic("Config file not supported yet"); + std.debug.print("Config file: TODO\n", .{}); + // const bytes = file.readToEndAlloc(b.allocator, 1 * 1000 * 1000) catch |err| { + // print("Unexpected error reading {s}: {s}\n", .{ config_path, @errorName(err) }); + // return err; + // }; + // var stream = std.json.TokenStream.init(bytes); + // if (std.json.parse(UserConfig, &stream, .{ .allocator = b.allocator })) |conf| { + // config = conf; + // } else |err| { + // print("Could not parse {s} ({s}).\n", .{ config_path, @errorName(err) }); + // return err; + // } } else |err| switch (err) { error.FileNotFound => { config_dirty = true; @@ -99,10 +101,10 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig const LSTATUS = u32; const DWORD = u32; - // const HKEY_CLASSES_ROOT = @intToPtr(HKEY, 0x80000000); - const HKEY_CURRENT_USER = @intToPtr(HKEY, 0x80000001); - const HKEY_LOCAL_MACHINE = @intToPtr(HKEY, 0x80000002); - // const HKEY_USERS = @intToPtr(HKEY, 0x80000003); + // const HKEY_CLASSES_ROOT: HKEY= @ptrFromInt(0x80000000); + const HKEY_CURRENT_USER: HKEY = @ptrFromInt(0x80000001); + const HKEY_LOCAL_MACHINE: HKEY = @ptrFromInt(0x80000002); + // const HKEY_USERS: HKEY= @ptrFromInt(0x80000003); // const RRF_RT_ANY: DWORD = 0xFFFF; // const RRF_RT_REG_BINARY: DWORD = 0x08; @@ -142,7 +144,7 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig // get the data const buffer = allocator.alloc(u8, len) catch unreachable; - len = @intCast(DWORD, buffer.len); + len = @as(DWORD, @intCast(buffer.len)); res = RegGetValueA(key, null, value, RRF_RT_REG_SZ, null, buffer.ptr, &len); if (res == ERROR_SUCCESS) { for (buffer[0..len], 0..) |c, i| { diff --git a/strings.xml b/strings.xml new file mode 100644 index 0000000..e69de29 From 0a3cd1cb2ac8bb007fd0cbca6791ad74c694ebc5 Mon Sep 17 00:00:00 2001 From: Jonas Everaert <62475953+Jomy10@users.noreply.github.com> Date: Tue, 26 Sep 2023 11:15:52 +0200 Subject: [PATCH 2/7] update to new JSON API Co-authored-by: Nigel Baillie --- build/auto-detect.zig | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/build/auto-detect.zig b/build/auto-detect.zig index 6b83097..670606c 100644 --- a/build/auto-detect.zig +++ b/build/auto-detect.zig @@ -26,17 +26,16 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig defer file.close(); // @panic("Config file not supported yet"); std.debug.print("Config file: TODO\n", .{}); - // const bytes = file.readToEndAlloc(b.allocator, 1 * 1000 * 1000) catch |err| { - // print("Unexpected error reading {s}: {s}\n", .{ config_path, @errorName(err) }); - // return err; - // }; - // var stream = std.json.TokenStream.init(bytes); - // if (std.json.parse(UserConfig, &stream, .{ .allocator = b.allocator })) |conf| { - // config = conf; - // } else |err| { - // print("Could not parse {s} ({s}).\n", .{ config_path, @errorName(err) }); - // return err; - // } + const bytes = file.readToEndAlloc(b.allocator, 1 * 1000 * 1000) catch |err| { + print("Unexpected error reading {s}: {s}\n", .{ config_path, @errorName(err) }); + return err; + }; + if (std.json.parseFromSlice(UserConfig, b.allocator, bytes, .{})) |conf| { + config = conf.value; + } else |err| { + print("Could not parse {s} ({s}).\n", .{ config_path, @errorName(err) }); + return err; + } } else |err| switch (err) { error.FileNotFound => { config_dirty = true; From 7da6461fe0d5d59306953ff479def6d58563da6e Mon Sep 17 00:00:00 2001 From: Felipe Jorge Date: Sun, 17 Dec 2023 08:17:47 -0300 Subject: [PATCH 3/7] fix build for zig 12 --- .vscode/c_cpp_properties.json | 17 - .vscode/settings.json | 28 - Sdk.zig | 63 +- build.zig | 2 +- build/auto-detect.zig | 10 +- examples/egl/main.zig | 92 +-- examples/egl/main1.zig | 904 +++++++++++++++++++++++++ src/NativeActivity.zig | 10 +- src/NativeInvocationHandler.zig | 6 +- src/aaudio.zig | 22 +- src/android-bind.zig | 1090 +++++++++++++++---------------- src/android-support.zig | 8 +- src/audio.zig | 2 +- src/egl.zig | 4 +- src/jni.zig | 4 +- src/opensl.zig | 36 +- 16 files changed, 1572 insertions(+), 726 deletions(-) delete mode 100644 .vscode/c_cpp_properties.json delete mode 100644 .vscode/settings.json create mode 100644 examples/egl/main1.zig diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json deleted file mode 100644 index 6c4786e..0000000 --- a/.vscode/c_cpp_properties.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "configurations": [ - { - "name": "Linux", - "includePath": [ - "${workspaceFolder}/**", - "/home/felix/projects/android-hass/android-sdk/ndk/21.1.6352462/sysroot/usr/include" - ], - "defines": [], - "compilerPath": "/usr/bin/clang", - "cStandard": "c11", - "cppStandard": "c++14", - "intelliSenseMode": "clang-x64" - } - ], - "version": 4 -} \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 81c0f99..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,28 +0,0 @@ -{ - "files.associations": { - "ios": "c", - "condition_variable": "c", - "array": "c", - "hash_map": "c", - "bitset": "c", - "string_view": "c", - "initializer_list": "c", - "ranges": "c", - "utility": "c", - "valarray": "c", - "__hash_table": "c", - "__split_buffer": "c", - "__tree": "c", - "deque": "c", - "iterator": "c", - "list": "c", - "map": "c", - "queue": "c", - "random": "c", - "set": "c", - "stack": "c", - "string": "c", - "unordered_map": "c", - "vector": "c" - } -} \ No newline at end of file diff --git a/Sdk.zig b/Sdk.zig index a54bcfa..6d22fe2 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -501,8 +501,7 @@ pub fn createApp( } resource_dir_step.add(Resource{ .path = "values/strings.xml", - // .content = write_xml_step.getFileSource("strings.xml").?, - .content = write_xml_step.addCopyFile(.{ .path = "strings.xml" }, ""), + .content = write_xml_step.files.items[0].getPath(), }); const sdk_version_int = @intFromEnum(app_config.target_version); @@ -548,11 +547,10 @@ pub fn createApp( const unaligned_apk_file = make_unsigned_apk.addOutputFileArg(unaligned_apk_name); make_unsigned_apk.addArg("-M"); // specify full path to AndroidManifest.xml to include in zip - // make_unsigned_apk.addFileSourceArg(manifest_step.getFileSource("AndroidManifest.xml").?); - make_unsigned_apk.addFileSourceArg(manifest_step.addCopyFile(.{ .path = "AndroidManifest.xml" }, "")); + make_unsigned_apk.addFileArg(manifest_step.files.items[0].getPath()); make_unsigned_apk.addArg("-S"); // directory in which to find resources. Multiple directories will be scanned and the first match found (left to right) will take precedence - make_unsigned_apk.addDirectorySourceArg(resource_dir_step.getOutputDirectory()); + make_unsigned_apk.addDirectoryArg(resource_dir_step.getOutputDirectory()); make_unsigned_apk.addArgs(&[_][]const u8{ "-v", @@ -593,7 +591,7 @@ pub fn createApp( "-v", // verbose "4", }); - align_step.addFileSourceArg(copy_to_zip_step.output_source); + align_step.addFileArg(copy_to_zip_step.output_source); align_step.step.dependOn(&make_unsigned_apk.step); const apk_file = align_step.addOutputFileArg(apk_filename); @@ -615,13 +613,13 @@ pub fn createApp( "-d", java_dir, }); - javac_cmd.addFileSourceArg(std.build.FileSource.relative(java_file)); + javac_cmd.addFileArg(std.build.FileSource.relative(java_file)); const name = std.fs.path.stem(java_file); const name_ext = sdk.b.fmt("{s}.class", .{name}); const class_file = std.fs.path.resolve(sdk.b.allocator, &[_][]const u8{ java_dir, name_ext }) catch unreachable; - d8_cmd_builder.addFileSourceArg(.{ .path = class_file }); + d8_cmd_builder.addFileArg(.{ .path = class_file }); d8_cmd_builder.step.dependOn(&javac_cmd.step); } @@ -640,6 +638,11 @@ pub fn createApp( align_step.step.dependOn(©_to_zip_step.run_step.step); } + if (!auto_detect.fileExists(key_store.file)) { + // sadly we lack a FailStep + std.log.err("missing keystore file at `{s}`", .{key_store.file}); + } + // const sign_step = sdk.signApk(apk_filename, key_store); const sign_step = sdk.b.addSystemCommand(&[_][]const u8{ sdk.system_tools.apksigner, @@ -651,7 +654,7 @@ pub fn createApp( { const pass = sdk.b.fmt("pass:{s}", .{key_store.password}); sign_step.addArgs(&.{ "--ks-pass", pass }); - sign_step.addFileSourceArg(apk_file); + sign_step.addFileArg(apk_file); } inline for (std.meta.fields(AppTargetConfig)) |fld| { @@ -678,6 +681,7 @@ pub fn createApp( copy_to_zip_step.addFile(step.getOutputSource(), target_filename); copy_to_zip_step.run_step.step.dependOn(&step.step); + // why this is inside the for loop align_step.step.dependOn(©_to_zip_step.run_step.step); } } @@ -769,8 +773,8 @@ const CreateResourceDirectory = struct { fn run_copy_to_zip(sdk: *Sdk, input_file: std.build.FileSource, apk_file: std.build.FileSource, target_file: []const u8) *std.Build.RunStep { const run_cp = sdk.b.addRunArtifact(sdk.host_tools.zip_add); - run_cp.addFileSourceArg(apk_file); - run_cp.addFileSourceArg(input_file); + run_cp.addFileArg(apk_file); + run_cp.addFileArg(input_file); run_cp.addArg(target_file); return run_cp; @@ -783,7 +787,7 @@ const WriteToZip = struct { pub fn init(sdk: *Sdk, zip_file: std.Build.FileSource, out_name: []const u8) WriteToZip { const run_cp = sdk.b.addRunArtifact(sdk.host_tools.zip_add); - run_cp.addFileSourceArg(zip_file); + run_cp.addFileArg(zip_file); const output_source = run_cp.addOutputFileArg(out_name); return WriteToZip{ @@ -793,7 +797,7 @@ const WriteToZip = struct { } pub fn addFile(step: *const WriteToZip, input_file: std.Build.FileSource, target_file: []const u8) void { - step.run_step.addFileSourceArg(input_file); + step.run_step.addFileArg(input_file); step.run_step.addArg(target_file); } }; @@ -927,7 +931,7 @@ fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const const step = sdk.b.addWriteFile(fname, contents.items); // return step.getFileSource(fname) orelse unreachable; - return step.addCopyFile(.{ .path = fname }, ""); + return step.files.items[0].getPath(); } pub fn compressApk(sdk: Sdk, input_apk_file: []const u8, output_apk_file: []const u8) *Step { @@ -967,7 +971,7 @@ pub fn compressApk(sdk: Sdk, input_apk_file: []const u8, output_apk_file: []cons pub fn installApp(sdk: Sdk, apk_file: std.build.FileSource) *Step { const step = sdk.b.addSystemCommand(&[_][]const u8{ sdk.system_tools.adb, "install" }); - step.addFileSourceArg(apk_file); + step.addFileArg(apk_file); return &step.step; } @@ -998,18 +1002,17 @@ pub fn startApp(sdk: Sdk, package_name: []const u8) *Step { pub const KeyConfig = struct { pub const Algorithm = enum { RSA }; key_algorithm: Algorithm = .RSA, - key_size: u32 = 2048, // bits + key_size: u32 = 4096, // bits validity: u32 = 10_000, // days - distinguished_name: []const u8 = "CN=example.com, OU=ID, O=Example, L=Doe, S=John, C=GB", + distinguished_name: []const u8 = "CN=Unknown, OU=Unknown, O=Unknown, L=Unknown, S=Unknown, C=Unknown", }; /// A build step that initializes a new key store from the given configuration. /// `android_config.key_store` must be non-`null` as it is used to initialize the key store. pub fn initKeystore(sdk: Sdk, key_store: KeyStore, key_config: KeyConfig) *Step { if (auto_detect.fileExists(key_store.file)) { - std.log.warn("keystore already exists: {s}", .{key_store.file}); return sdk.b.step("init_keystore_noop", "Do nothing, since key exists"); } else { - const step = sdk.b.addSystemCommand(&[_][]const u8{ + const args = &[_][]const u8{ sdk.system_tools.keytool, "-genkey", "-v", @@ -1029,8 +1032,10 @@ pub fn initKeystore(sdk: Sdk, key_store: KeyStore, key_config: KeyConfig) *Step key_store.password, "-dname", key_config.distinguished_name, - }); - return &step.step; + }; + + const run = sdk.b.addSystemCommand(args); + return &run.step; } } @@ -1152,22 +1157,6 @@ const BuildOptionStep = struct { } return; }, - // std.builtin.Version => { - // out.print( - // \\pub const {}: @import("std").builtin.Version = .{{ - // \\ .major = {d}, - // \\ .minor = {d}, - // \\ .patch = {d}, - // \\}}; - // \\ - // , .{ - // std.zig.fmtId(name), - - // value.major, - // value.minor, - // value.patch, - // }) catch unreachable; - // }, std.SemanticVersion => { out.print( \\pub const {}: @import("std").SemanticVersion = .{{ diff --git a/build.zig b/build.zig index ea7a0e4..1c6682d 100644 --- a/build.zig +++ b/build.zig @@ -11,7 +11,7 @@ pub fn build(b: *std.build.Builder) !void { const mode = b.standardOptimizeOption(.{}); const android_version = b.option(Sdk.AndroidVersion, "android", "Select the android version, default is 'android5'") orelse .android5; const aaudio = b.option(bool, "aaudio", "Compile with support for AAudio, default is 'false'") orelse false; - const opensl = b.option(bool, "opensl", "Compile with support for OpenSL ES, default is 'true'") orelse true; + const opensl = b.option(bool, "opensl", "Compile with support for OpenSL ES, default is 'false'") orelse false; // Provide some KeyStore structure so we can sign our app. // Recommendation: Don't hardcore your password here, everyone can read it. diff --git a/build/auto-detect.zig b/build/auto-detect.zig index 670606c..7d6b506 100644 --- a/build/auto-detect.zig +++ b/build/auto-detect.zig @@ -24,14 +24,12 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig // Check for a user config file. if (std.fs.cwd().openFile(config_path, .{})) |file| { defer file.close(); - // @panic("Config file not supported yet"); - std.debug.print("Config file: TODO\n", .{}); - const bytes = file.readToEndAlloc(b.allocator, 1 * 1000 * 1000) catch |err| { + const bytes = file.readToEndAlloc(b.allocator, 2 * 1024 * 1024) catch |err| { print("Unexpected error reading {s}: {s}\n", .{ config_path, @errorName(err) }); return err; }; - if (std.json.parseFromSlice(UserConfig, b.allocator, bytes, .{})) |conf| { - config = conf.value; + if (std.json.parseFromSliceLeaky(UserConfig, b.allocator, bytes, .{})) |conf| { + config = conf; } else |err| { print("Could not parse {s} ({s}).\n", .{ config_path, @errorName(err) }); return err; @@ -157,7 +155,7 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig }; // Get the android studio registry entry - var android_studio_key: HKEY = for ([_]HKEY{ HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE }) |root_key| { + const android_studio_key: HKEY = for ([_]HKEY{ HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE }) |root_key| { var software: HKEY = null; if (reg.RegOpenKeyA(root_key, "software", &software) == ERROR_SUCCESS) { defer _ = reg.RegCloseKey(software); diff --git a/examples/egl/main.zig b/examples/egl/main.zig index a9b8593..e421299 100644 --- a/examples/egl/main.zig +++ b/examples/egl/main.zig @@ -93,8 +93,8 @@ pub const AndroidApp = struct { old.deinit(); } - self.screen_width = @intToFloat(f32, android.ANativeWindow_getWidth(window)); - self.screen_height = @intToFloat(f32, android.ANativeWindow_getHeight(window)); + self.screen_width = @as(f32, @floatFromInt(android.ANativeWindow_getWidth(window))); + self.screen_height = @as(f32, @floatFromInt(android.ANativeWindow_getHeight(window))); self.egl = EGLContext.init(window, .gles2) catch |err| blk: { app_log.err("Failed to initialize EGL for window: {}\n", .{err}); @@ -177,7 +177,7 @@ pub const AndroidApp = struct { } fn processKeyEvent(self: *Self, event: *android.AInputEvent) !bool { - const event_type = @intToEnum(android.AKeyEventActionType, android.AKeyEvent_getAction(event)); + const event_type = @as(android.AKeyEventActionType, @enumFromInt(android.AKeyEvent_getAction(event))); std.log.scoped(.input).debug( \\Key Press Event: {} \\ Flags: {} @@ -203,14 +203,14 @@ pub const AndroidApp = struct { var native_activity = NativeActivity.init(self.activity); defer native_activity.deinit(); - var codepoint = try native_activity.AndroidGetUnicodeChar( + const codepoint = try native_activity.AndroidGetUnicodeChar( android.AKeyEvent_getKeyCode(event), android.AKeyEvent_getMetaState(event), ); var buf: [8]u8 = undefined; - var len = std.unicode.utf8Encode(codepoint, &buf) catch 0; - var key_text = buf[0..len]; + const len = std.unicode.utf8Encode(codepoint, &buf) catch 0; + const key_text = buf[0..len]; std.log.scoped(.input).info("Pressed key: '{s}' U+{X}", .{ key_text, codepoint }); } @@ -223,7 +223,7 @@ pub const AndroidApp = struct { var oldest: *TouchPoint = undefined; if (point.index) |index| { - self.simple_synth.oscillators[@intCast(usize, index)].setWaveOn(true); + self.simple_synth.oscillators[@as(usize, @intCast(index))].setWaveOn(true); } for (&self.touch_points, 0..) |*opt, i| { @@ -249,7 +249,7 @@ pub const AndroidApp = struct { } fn processMotionEvent(self: *Self, event: *android.AInputEvent) !bool { - const event_type = @intToEnum(android.AMotionEventActionType, android.AMotionEvent_getAction(event)); + const event_type = @as(android.AMotionEventActionType, @enumFromInt(android.AMotionEvent_getAction(event))); { var native_activity = NativeActivity.init(self.activity); @@ -301,7 +301,7 @@ pub const AndroidApp = struct { }); var i: usize = 0; - var cnt = android.AMotionEvent_getPointerCount(event); + const cnt = android.AMotionEvent_getPointerCount(event); while (i < cnt) : (i += 1) { std.log.scoped(.input).debug( \\Pointer {}: @@ -360,7 +360,7 @@ pub const AndroidApp = struct { app_log.info("mainLoop() started\n", .{}); self.config = blk: { - var cfg = android.AConfiguration_new() orelse return error.OutOfMemory; + const cfg = android.AConfiguration_new() orelse return error.OutOfMemory; android.AConfiguration_fromAssetManager(cfg, self.activity.assetManager); break :blk cfg; }; @@ -428,7 +428,7 @@ pub const AndroidApp = struct { continue; } - const event_type = @intToEnum(android.AInputEventType, android.AInputEvent_getType(event)); + const event_type = @as(android.AInputEventType, @enumFromInt(android.AInputEvent_getType(event))); const handled = switch (event_type) { .AINPUT_EVENT_TYPE_KEY => try self.processKeyEvent(event.?), .AINPUT_EVENT_TYPE_MOTION => try self.processMotionEvent(event.?), @@ -470,8 +470,8 @@ pub const AndroidApp = struct { touch_program = c.glCreateProgram(); { - var ps = c.glCreateShader(c.GL_VERTEX_SHADER); - var fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); + const ps = c.glCreateShader(c.GL_VERTEX_SHADER); + const fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); var ps_code = \\attribute vec2 vPosition; @@ -495,8 +495,8 @@ pub const AndroidApp = struct { \\ ; - c.glShaderSource(ps, 1, @ptrCast([*c]const [*c]const u8, &ps_code), null); - c.glShaderSource(fs, 1, @ptrCast([*c]const [*c]const u8, &fs_code), null); + c.glShaderSource(ps, 1, @as([*c]const [*c]const u8, @ptrCast(&ps_code)), null); + c.glShaderSource(fs, 1, @as([*c]const [*c]const u8, @ptrCast(&fs_code)), null); c.glCompileShader(ps); c.glCompileShader(fs); @@ -529,17 +529,17 @@ pub const AndroidApp = struct { // Get attrib locations const vPosition_res = c.glGetAttribLocation(touch_program, "vPosition"); app_log.info("vPosition: {}", .{vPosition_res}); - vPosition = @intCast(c.GLuint, vPosition_res); + vPosition = @as(c.GLuint, @intCast(vPosition_res)); // Bind the vertices to the buffer c.glGenBuffers(1, &touch_buffer); c.glBindBuffer(c.GL_ARRAY_BUFFER, touch_buffer); - c.glBufferData(c.GL_ARRAY_BUFFER, @intCast(isize, vVertices[0..].len * @sizeOf(c.GLfloat)), vVertices[0..], c.GL_STATIC_DRAW); + c.glBufferData(c.GL_ARRAY_BUFFER, @as(isize, @intCast(vVertices[0..].len * @sizeOf(c.GLfloat))), vVertices[0..], c.GL_STATIC_DRAW); shaded_program = c.glCreateProgram(); { - var ps = c.glCreateShader(c.GL_VERTEX_SHADER); - var fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); + const ps = c.glCreateShader(c.GL_VERTEX_SHADER); + const fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); var ps_code = \\#version 100 @@ -565,8 +565,8 @@ pub const AndroidApp = struct { \\ ; - c.glShaderSource(ps, 1, @ptrCast([*c]const [*c]const u8, &ps_code), null); - c.glShaderSource(fs, 1, @ptrCast([*c]const [*c]const u8, &fs_code), null); + c.glShaderSource(ps, 1, @as([*c]const [*c]const u8, @ptrCast(&ps_code)), null); + c.glShaderSource(fs, 1, @as([*c]const [*c]const u8, @ptrCast(&fs_code)), null); c.glCompileShader(ps); c.glCompileShader(fs); @@ -592,20 +592,20 @@ pub const AndroidApp = struct { // Get attrib locations const mesh_vPosition_res = c.glGetAttribLocation(shaded_program, "vPosition"); app_log.info("mesh_vPosition: {}", .{mesh_vPosition_res}); - mesh_vPosition = @intCast(c.GLuint, mesh_vPosition_res); + mesh_vPosition = @as(c.GLuint, @intCast(mesh_vPosition_res)); const mesh_vNormal_res = c.glGetAttribLocation(shaded_program, "vNormal"); app_log.info("mesh_vNormal: {}", .{mesh_vNormal_res}); - mesh_vNormal = @intCast(c.GLuint, mesh_vNormal_res); + mesh_vNormal = @as(c.GLuint, @intCast(mesh_vNormal_res)); // Bind the vertices to the buffer c.glGenBuffers(1, &mesh_buffer); c.glBindBuffer(c.GL_ARRAY_BUFFER, mesh_buffer); - c.glBufferData(c.GL_ARRAY_BUFFER, @intCast(isize, mesh.len * @sizeOf(MeshVertex)), &mesh, c.GL_STATIC_DRAW); + c.glBufferData(c.GL_ARRAY_BUFFER, @as(isize, @intCast(mesh.len * @sizeOf(MeshVertex))), &mesh, c.GL_STATIC_DRAW); self.egl_init = false; } - const t = @intToFloat(f32, loop) / 100.0; + const t = @as(f32, @floatFromInt(loop)) / 100.0; // Clear the screen c.glClearColor( @@ -622,7 +622,7 @@ pub const AndroidApp = struct { c.glBindBuffer(c.GL_ARRAY_BUFFER, touch_buffer); c.glEnableVertexAttribArray(vPosition); - c.glVertexAttribPointer(vPosition, 2, c.GL_FLOAT, c.GL_FALSE, 0, @intToPtr(?*anyopaque, 0)); + c.glVertexAttribPointer(vPosition, 2, c.GL_FLOAT, c.GL_FALSE, 0, @as(?*anyopaque, @ptrFromInt(0))); // c.glDisableVertexAttribArray(1); @@ -641,7 +641,7 @@ pub const AndroidApp = struct { point.intensity -= 0.05; if (point.intensity <= 0.0) { if (point.index) |index| { - self.simple_synth.oscillators[@intCast(usize, index)].setWaveOn(false); + self.simple_synth.oscillators[@as(usize, @intCast(index))].setWaveOn(false); } pt.* = null; } @@ -652,10 +652,10 @@ pub const AndroidApp = struct { // -- Start 3d zig logo code c.glBindBuffer(c.GL_ARRAY_BUFFER, mesh_buffer); c.glEnableVertexAttribArray(mesh_vPosition); - c.glVertexAttribPointer(mesh_vPosition, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @intToPtr(?*anyopaque, @offsetOf(MeshVertex, "pos"))); + c.glVertexAttribPointer(mesh_vPosition, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @as(?*anyopaque, @ptrFromInt(@offsetOf(MeshVertex, "pos")))); c.glEnableVertexAttribArray(mesh_vNormal); - c.glVertexAttribPointer(mesh_vNormal, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @intToPtr(?*anyopaque, @offsetOf(MeshVertex, "normal"))); + c.glVertexAttribPointer(mesh_vNormal, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @as(?*anyopaque, @ptrFromInt(@offsetOf(MeshVertex, "normal")))); c.glUseProgram(shaded_program); @@ -679,7 +679,7 @@ pub const AndroidApp = struct { matrix[0][2] = @cos(t); matrix[2][2] = -@sin(t); - c.glUniformMatrix4fv(uTransform, 1, c.GL_FALSE, @ptrCast([*]const f32, &matrix)); + c.glUniformMatrix4fv(uTransform, 1, c.GL_FALSE, @as([*]const f32, @ptrCast(&matrix))); c.glDrawArrays(c.GL_TRIANGLES, 0, mesh.len); @@ -709,9 +709,9 @@ const Vector4 = extern struct { fn readFromSlice(slice: []const u8) Vector4 { return Vector4{ - .x = @bitCast(f32, std.mem.readIntLittle(u32, slice[0..4])), - .y = @bitCast(f32, std.mem.readIntLittle(u32, slice[4..8])), - .z = @bitCast(f32, std.mem.readIntLittle(u32, slice[8..12])), + .x = @as(f32, @bitCast(std.mem.readInt(u32, slice[0..4], .little))), + .y = @as(f32, @bitCast(std.mem.readInt(u32, slice[4..8], .little))), + .z = @as(f32, @bitCast(std.mem.readInt(u32, slice[8..12], .little))), .w = 1.0, }; } @@ -720,7 +720,7 @@ const Vector4 = extern struct { const mesh = blk: { const stl_data = @embedFile("logo.stl"); - const count = std.mem.readIntLittle(u32, stl_data[80..][0..4]); + const count = std.mem.readInt(u32, stl_data[80..][0..4], .little); var slice: []const u8 = stl_data[84..]; @@ -734,7 +734,7 @@ const mesh = blk: { const v1 = Vector4.readFromSlice(slice[12..]); const v2 = Vector4.readFromSlice(slice[24..]); const v3 = Vector4.readFromSlice(slice[36..]); - const attrib_count = std.mem.readIntLittle(u16, slice[48..50]); + const attrib_count = std.mem.readInt(u16, slice[48..50], .little); array[3 * index + 0] = MeshVertex{ .pos = v1, @@ -760,7 +760,7 @@ pub fn glProgramInfoLog(program: c.GLuint) void { var size: c.GLsizei = undefined; c.glGetProgramInfoLog(program, 4096, &size, &buffer); if (size == 0) return; - app_log.info("{s}", .{buffer[0..@intCast(usize, size)]}); + app_log.info("{s}", .{buffer[0..@as(usize, @intCast(size))]}); } pub fn glShaderInfoLog(shader: c.GLuint) void { @@ -768,7 +768,7 @@ pub fn glShaderInfoLog(shader: c.GLuint) void { var size: c.GLsizei = undefined; c.glGetShaderInfoLog(shader, 4096, &size, &buffer); if (size == 0) return; - app_log.info("{s}", .{buffer[0..@intCast(usize, size)]}); + app_log.info("{s}", .{buffer[0..@as(usize, @intCast(size))]}); } pub fn glCheckError(res: i64) void { @@ -798,10 +798,10 @@ pub fn enableDebug() void { c.glEnable(c.GL_DEBUG_OUTPUT_KHR); c.glEnable(c.GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR); - const glDebugMessageControl = @ptrCast(c.PFNGLDEBUGMESSAGECONTROLKHRPROC, c.eglGetProcAddress("glDebugMessageControl")).?; + const glDebugMessageControl = @as(c.PFNGLDEBUGMESSAGECONTROLKHRPROC, @ptrCast(c.eglGetProcAddress("glDebugMessageControl"))).?; glDebugMessageControl(c.GL_DONT_CARE, c.GL_DONT_CARE, c.GL_DEBUG_SEVERITY_NOTIFICATION_KHR, 0, null, c.GL_TRUE); - const glDebugMessageCallback = @ptrCast(c.PFNGLDEBUGMESSAGECALLBACKKHRPROC, c.eglGetProcAddress("glDebugMessageCallback")).?; + const glDebugMessageCallback = @as(c.PFNGLDEBUGMESSAGECALLBACKKHRPROC, @ptrCast(c.eglGetProcAddress("glDebugMessageCallback"))).?; glDebugMessageCallback(debugMessageCallback, null); } else { app_log.err("Debug is not supported.", .{}); @@ -820,7 +820,7 @@ pub fn debugMessageCallback( _ = user_param; const message = message: { if (message_c) |message_ptr| { - break :message if (length > 0) message_ptr[0..@intCast(usize, length)] else ""; + break :message if (length > 0) message_ptr[0..@as(usize, @intCast(length))] else ""; } else { break :message ""; } @@ -850,7 +850,7 @@ const Oscillator = struct { } fn setSampleRate(self: *@This(), sample_rate: i32) void { - self.phaseIncrement = (std.math.tau * self.frequency) / @intToFloat(f64, sample_rate); + self.phaseIncrement = (std.math.tau * self.frequency) / @as(f64, @floatFromInt(sample_rate)); } fn renderf32(self: *@This(), audio_data: []f32) void { @@ -858,7 +858,7 @@ const Oscillator = struct { for (audio_data) |*frame| { if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { - frame.* += @floatCast(f32, std.math.sin(self.phase) * self.amplitude); + frame.* += @as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)); self.phase += self.phaseIncrement; if (self.phase > std.math.tau) self.phase -= std.math.tau; } @@ -870,7 +870,7 @@ const Oscillator = struct { for (audio_data) |*frame| { if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { - frame.* +|= @floatToInt(i16, @floatCast(f32, std.math.sin(self.phase) * self.amplitude) * std.math.maxInt(i16)); + frame.* +|= @as(i16, @intFromFloat(@as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)) * std.math.maxInt(i16))); self.phase += self.phaseIncrement; if (self.phase > std.math.tau) self.phase -= std.math.tau; } @@ -886,18 +886,18 @@ const SimpleSynth = struct { for (&synth.oscillators, 0..) |*osc, index| { osc.* = Oscillator{ .frequency = audio.midiToFreq(49 + index * 3), - .amplitude = audio.dBToAmplitude(-@intToFloat(f64, index) - 15), + .amplitude = audio.dBToAmplitude(-@as(f64, @floatFromInt(index)) - 15), }; } return synth; } fn audioCallback(stream: audio.StreamLayout, user_data: *anyopaque) void { - var synth = @ptrCast(*SimpleSynth, @alignCast(@alignOf(SimpleSynth), user_data)); + var synth = @as(*SimpleSynth, @ptrCast(@alignCast(user_data))); std.debug.assert(stream.buffer == .Int16); for (&synth.oscillators) |*osc| { - osc.setSampleRate(@intCast(i32, stream.sample_rate)); + osc.setSampleRate(@as(i32, @intCast(stream.sample_rate))); osc.renderi16(stream.buffer.Int16); } } diff --git a/examples/egl/main1.zig b/examples/egl/main1.zig new file mode 100644 index 0000000..bc8e66b --- /dev/null +++ b/examples/egl/main1.zig @@ -0,0 +1,904 @@ +const std = @import("std"); + +const android = @import("android"); + +// const audio = android.audio; +pub const panic = android.panic; + +const EGLContext = android.egl.EGLContext; +const JNI = android.JNI; +const NativeActivity = android.NativeActivity; +const c = android.egl.c; + +const app_log = std.log.scoped(.app); + +comptime { + _ = android.ANativeActivity_createFunc; +} + +/// Entry point for our application. +/// This struct provides the interface to the android support package. +pub const AndroidApp = struct { + const Self = @This(); + + const TouchPoint = struct { + /// if null, then fade out + index: ?i32, + intensity: f32, + x: f32, + y: f32, + age: i64, + }; + + allocator: std.mem.Allocator, + activity: *android.ANativeActivity, + + thread: ?std.Thread = null, + running: bool = true, + + egl_lock: std.Thread.Mutex = .{}, + egl: ?EGLContext = null, + egl_init: bool = true, + + input_lock: std.Thread.Mutex = .{}, + input: ?*android.AInputQueue = null, + + config: ?*android.AConfiguration = null, + + touch_points: [16]?TouchPoint = [1]?TouchPoint{null} ** 16, + screen_width: f32 = undefined, + screen_height: f32 = undefined, + + // // audio_engine: audio.AudioEngine = .{}, + // simple_synth: SimpleSynth = undefined, + + /// This is the entry point which initializes a application + /// that has stored its previous state. + /// `stored_state` is that state, the memory is only valid for this function. + pub fn init(allocator: std.mem.Allocator, activity: *android.ANativeActivity, stored_state: ?[]const u8) !Self { + _ = stored_state; + + return Self{ + .allocator = allocator, + .activity = activity, + }; + } + + /// This function is called when the application is successfully initialized. + /// It should create a background thread that processes the events and runs until + /// the application gets destroyed. + pub fn start(self: *Self) !void { + self.thread = try std.Thread.spawn(.{}, mainLoop, .{self}); + } + + /// Uninitialize the application. + /// Don't forget to stop your background thread here! + pub fn deinit(self: *Self) void { + @atomicStore(bool, &self.running, false, .SeqCst); + if (self.thread) |thread| { + thread.join(); + self.thread = null; + } + if (self.config) |config| { + android.AConfiguration_delete(config); + } + self.* = undefined; + } + + pub fn onNativeWindowCreated(self: *Self, window: *android.ANativeWindow) void { + self.egl_lock.lock(); + defer self.egl_lock.unlock(); + + if (self.egl) |*old| { + old.deinit(); + } + + self.screen_width = @as(f32, @floatFromInt(android.ANativeWindow_getWidth(window))); + self.screen_height = @as(f32, @floatFromInt(android.ANativeWindow_getHeight(window))); + + self.egl = EGLContext.init(window, .gles2) catch |err| blk: { + app_log.err("Failed to initialize EGL for window: {}\n", .{err}); + break :blk null; + }; + self.egl_init = true; + } + + pub fn onNativeWindowDestroyed(self: *Self, window: *android.ANativeWindow) void { + _ = window; + self.egl_lock.lock(); + defer self.egl_lock.unlock(); + + if (self.egl) |*old| { + old.deinit(); + } + self.egl = null; + } + + pub fn onInputQueueCreated(self: *Self, input: *android.AInputQueue) void { + self.input_lock.lock(); + defer self.input_lock.unlock(); + + self.input = input; + } + + pub fn onInputQueueDestroyed(self: *Self, input: *android.AInputQueue) void { + _ = input; + + self.input_lock.lock(); + defer self.input_lock.unlock(); + + self.input = null; + } + + fn printConfig(config: *android.AConfiguration) void { + var lang: [2]u8 = undefined; + var country: [2]u8 = undefined; + + android.AConfiguration_getLanguage(config, &lang); + android.AConfiguration_getCountry(config, &country); + + app_log.debug( + \\App Configuration: + \\ MCC: {} + \\ MNC: {} + \\ Language: {s} + \\ Country: {s} + \\ Orientation: {} + \\ Touchscreen: {} + \\ Density: {} + \\ Keyboard: {} + \\ Navigation: {} + \\ KeysHidden: {} + \\ NavHidden: {} + \\ SdkVersion: {} + \\ ScreenSize: {} + \\ ScreenLong: {} + \\ UiModeType: {} + \\ UiModeNight: {} + \\ + , .{ + android.AConfiguration_getMcc(config), + android.AConfiguration_getMnc(config), + &lang, + &country, + android.AConfiguration_getOrientation(config), + android.AConfiguration_getTouchscreen(config), + android.AConfiguration_getDensity(config), + android.AConfiguration_getKeyboard(config), + android.AConfiguration_getNavigation(config), + android.AConfiguration_getKeysHidden(config), + android.AConfiguration_getNavHidden(config), + android.AConfiguration_getSdkVersion(config), + android.AConfiguration_getScreenSize(config), + android.AConfiguration_getScreenLong(config), + android.AConfiguration_getUiModeType(config), + android.AConfiguration_getUiModeNight(config), + }); + } + + fn processKeyEvent(self: *Self, event: *android.AInputEvent) !bool { + const event_type = @as(android.AKeyEventActionType, @enumFromInt(android.AKeyEvent_getAction(event))); + std.log.scoped(.input).debug( + \\Key Press Event: {} + \\ Flags: {} + \\ KeyCode: {} + \\ ScanCode: {} + \\ MetaState: {} + \\ RepeatCount: {} + \\ DownTime: {} + \\ EventTime: {} + \\ + , .{ + event_type, + android.AKeyEvent_getFlags(event), + android.AKeyEvent_getKeyCode(event), + android.AKeyEvent_getScanCode(event), + android.AKeyEvent_getMetaState(event), + android.AKeyEvent_getRepeatCount(event), + android.AKeyEvent_getDownTime(event), + android.AKeyEvent_getEventTime(event), + }); + + if (event_type == .AKEY_EVENT_ACTION_DOWN) { + var native_activity = NativeActivity.init(self.activity); + defer native_activity.deinit(); + + const codepoint = try native_activity.AndroidGetUnicodeChar( + android.AKeyEvent_getKeyCode(event), + android.AKeyEvent_getMetaState(event), + ); + var buf: [8]u8 = undefined; + + const len = std.unicode.utf8Encode(codepoint, &buf) catch 0; + const key_text = buf[0..len]; + + std.log.scoped(.input).info("Pressed key: '{s}' U+{X}", .{ key_text, codepoint }); + } + + return false; + } + + fn insertPoint(self: *Self, point: TouchPoint) void { + std.debug.assert(point.index != null); + var oldest: *TouchPoint = undefined; + + // if (point.index) |index| { + // self.simple_synth.oscillators[@as(usize, @intCast(index))].setWaveOn(true); + // } + + for (&self.touch_points, 0..) |*opt, i| { + if (opt.*) |*pt| { + if (pt.index != null and pt.index.? == point.index.?) { + pt.* = point; + return; + } + + if (i == 0) { + oldest = pt; + } else { + if (pt.age < oldest.age) { + oldest = pt; + } + } + } else { + opt.* = point; + return; + } + } + oldest.* = point; + } + + fn processMotionEvent(self: *Self, event: *android.AInputEvent) !bool { + const event_type = @as(android.AMotionEventActionType, @enumFromInt(android.AMotionEvent_getAction(event))); + + { + var native_activity = NativeActivity.init(self.activity); + defer native_activity.deinit(); + + // Show/Hide keyboard + // _ = native_activity.AndroidDisplayKeyboard(true); + + // this allows you to send the app in the background + // const success = native_activity.AndroidSendToBack(true); + // _ = success; + // std.log.scoped(.input).debug("SendToBack() = {}\n", .{success}); + + // This is a demo on how to request permissions: + if (event_type == .AMOTION_EVENT_ACTION_UP) { + if (!try NativeActivity.AndroidHasPermissions(&native_activity, "android.permission.RECORD_AUDIO")) { + try NativeActivity.AndroidRequestAppPermissions(&native_activity, "android.permission.RECORD_AUDIO"); + } + } + } + + std.log.scoped(.input).debug( + \\Motion Event {} + \\ Flags: {} + \\ MetaState: {} + \\ ButtonState: {} + \\ EdgeFlags: {} + \\ DownTime: {} + \\ EventTime: {} + \\ XOffset: {} + \\ YOffset: {} + \\ XPrecision: {} + \\ YPrecision: {} + \\ PointerCount: {} + \\ + , .{ + event_type, + android.AMotionEvent_getFlags(event), + android.AMotionEvent_getMetaState(event), + android.AMotionEvent_getButtonState(event), + android.AMotionEvent_getEdgeFlags(event), + android.AMotionEvent_getDownTime(event), + android.AMotionEvent_getEventTime(event), + android.AMotionEvent_getXOffset(event), + android.AMotionEvent_getYOffset(event), + android.AMotionEvent_getXPrecision(event), + android.AMotionEvent_getYPrecision(event), + android.AMotionEvent_getPointerCount(event), + }); + + var i: usize = 0; + const cnt = android.AMotionEvent_getPointerCount(event); + while (i < cnt) : (i += 1) { + std.log.scoped(.input).debug( + \\Pointer {}: + \\ PointerId: {} + \\ ToolType: {} + \\ RawX: {d} + \\ RawY: {d} + \\ X: {d} + \\ Y: {d} + \\ Pressure: {} + \\ Size: {} + \\ TouchMajor: {} + \\ TouchMinor: {} + \\ ToolMajor: {} + \\ ToolMinor: {} + \\ Orientation: {} + \\ + , .{ + i, + android.AMotionEvent_getPointerId(event, i), + android.AMotionEvent_getToolType(event, i), + android.AMotionEvent_getRawX(event, i), + android.AMotionEvent_getRawY(event, i), + android.AMotionEvent_getX(event, i), + android.AMotionEvent_getY(event, i), + android.AMotionEvent_getPressure(event, i), + android.AMotionEvent_getSize(event, i), + android.AMotionEvent_getTouchMajor(event, i), + android.AMotionEvent_getTouchMinor(event, i), + android.AMotionEvent_getToolMajor(event, i), + android.AMotionEvent_getToolMinor(event, i), + android.AMotionEvent_getOrientation(event, i), + }); + + self.insertPoint(TouchPoint{ + .x = android.AMotionEvent_getX(event, i), + .y = android.AMotionEvent_getY(event, i), + .index = android.AMotionEvent_getPointerId(event, i), + .age = android.AMotionEvent_getEventTime(event), + .intensity = 1.0, + }); + } + + return false; + } + + fn mainLoop(self: *Self) !void { + // This code somehow crashes yet. Needs more investigations + var native_activity = NativeActivity.init(self.activity); + defer native_activity.deinit(); + + // Must be called from main thread… + _ = try native_activity.AndroidMakeFullscreen(); + + var loop: usize = 0; + app_log.info("mainLoop() started\n", .{}); + + self.config = blk: { + const cfg = android.AConfiguration_new() orelse return error.OutOfMemory; + android.AConfiguration_fromAssetManager(cfg, self.activity.assetManager); + break :blk cfg; + }; + + if (self.config) |cfg| { + printConfig(cfg); + } + + // // Audio + // self.simple_synth = SimpleSynth.init(); + + // try audio.init(); + + // var output_stream = try audio.getOutputStream(self.allocator, .{ + // .sample_format = .Int16, + // .callback = SimpleSynth.audioCallback, + // .user_data = &self.simple_synth, + // }); + // defer { + // output_stream.stop(); + // output_stream.deinit(); + // } + + // try output_stream.start(); + + // Graphics + const GLuint = c.GLuint; + + var touch_program: GLuint = undefined; + var shaded_program: GLuint = undefined; + + var uPos: c.GLint = undefined; + var uAspect: c.GLint = undefined; + var uIntensity: c.GLint = undefined; + + var vPosition: c.GLuint = undefined; + + var uTransform: c.GLint = undefined; + + var mesh_vPosition: c.GLuint = undefined; + var mesh_vNormal: c.GLuint = undefined; + + var touch_buffer: c.GLuint = undefined; + var mesh_buffer: c.GLuint = undefined; + + const vVertices = [_]c.GLfloat{ + 0.0, 0.0, + 1.0, 0.0, + 0.0, 1.0, + 1.0, 1.0, + }; + + while (@atomicLoad(bool, &self.running, .SeqCst)) { + + // Input process + { + // we lock the handle of our input so we don't have a race condition + self.input_lock.lock(); + defer self.input_lock.unlock(); + if (self.input) |input| { + var event: ?*android.AInputEvent = undefined; + while (android.AInputQueue_getEvent(input, &event) >= 0) { + std.debug.assert(event != null); + if (android.AInputQueue_preDispatchEvent(input, event) != 0) { + continue; + } + + const event_type = @as(android.AInputEventType, @enumFromInt(android.AInputEvent_getType(event))); + const handled = switch (event_type) { + .AINPUT_EVENT_TYPE_KEY => try self.processKeyEvent(event.?), + .AINPUT_EVENT_TYPE_MOTION => try self.processMotionEvent(event.?), + else => blk: { + std.log.scoped(.input).debug("Unhandled input event type ({})\n", .{event_type}); + break :blk false; + }, + }; + + // if (app.onInputEvent != NULL) + // handled = app.onInputEvent(app, event); + android.AInputQueue_finishEvent(input, event, if (handled) @as(c_int, 1) else @as(c_int, 0)); + } + } + } + + // Render process + { + // same for the EGL context + self.egl_lock.lock(); + defer self.egl_lock.unlock(); + if (self.egl) |egl| { + try egl.makeCurrent(); + + if (self.egl_init) { + enableDebug(); + app_log.info( + \\GL Vendor: {s} + \\GL Renderer: {s} + \\GL Version: {s} + \\GL Extensions: {s} + \\ + , .{ + std.mem.span(c.glGetString(c.GL_VENDOR)), + std.mem.span(c.glGetString(c.GL_RENDERER)), + std.mem.span(c.glGetString(c.GL_VERSION)), + std.mem.span(c.glGetString(c.GL_EXTENSIONS)), + }); + + touch_program = c.glCreateProgram(); + { + const ps = c.glCreateShader(c.GL_VERTEX_SHADER); + const fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); + + var ps_code = + \\attribute vec2 vPosition; + \\varying vec2 uv; + \\void main() { + \\ uv = vPosition; + \\ gl_Position = vec4(2.0 * uv - 1.0, 0.0, 1.0); + \\} + \\ + ; + var fs_code = + \\varying highp vec2 uv; + \\uniform highp vec2 uPos; + \\uniform highp float uAspect; + \\uniform highp float uIntensity; + \\void main() { + \\ highp vec2 rel = uv - uPos; + \\ rel.x *= uAspect; + \\ gl_FragColor = vec4(vec3(pow(uIntensity * clamp(1.0 - 10.0 * length(rel), 0.0, 1.0), 2.2)), 1.0); + \\} + \\ + ; + + c.glShaderSource(ps, 1, @as([*c]const [*c]const u8, @ptrCast(&ps_code)), null); + c.glShaderSource(fs, 1, @as([*c]const [*c]const u8, @ptrCast(&fs_code)), null); + + c.glCompileShader(ps); + c.glCompileShader(fs); + + glCheckError(ps); + glCheckError(fs); + + c.glAttachShader(touch_program, ps); + c.glAttachShader(touch_program, fs); + + glShaderInfoLog(ps); + glShaderInfoLog(fs); + + c.glBindAttribLocation(touch_program, 0, "vPosition"); + c.glLinkProgram(touch_program); + + glCheckError(touch_program); + + c.glDetachShader(touch_program, ps); + c.glDetachShader(touch_program, fs); + + glProgramInfoLog(touch_program); + } + + // Get uniform locations + uPos = c.glGetUniformLocation(touch_program, "uPos"); + uAspect = c.glGetUniformLocation(touch_program, "uAspect"); + uIntensity = c.glGetUniformLocation(touch_program, "uIntensity"); + + // Get attrib locations + const vPosition_res = c.glGetAttribLocation(touch_program, "vPosition"); + app_log.info("vPosition: {}", .{vPosition_res}); + vPosition = @as(c.GLuint, @intCast(vPosition_res)); + + // Bind the vertices to the buffer + c.glGenBuffers(1, &touch_buffer); + c.glBindBuffer(c.GL_ARRAY_BUFFER, touch_buffer); + c.glBufferData(c.GL_ARRAY_BUFFER, @as(isize, @intCast(vVertices[0..].len * @sizeOf(c.GLfloat))), vVertices[0..], c.GL_STATIC_DRAW); + + shaded_program = c.glCreateProgram(); + { + const ps = c.glCreateShader(c.GL_VERTEX_SHADER); + const fs = c.glCreateShader(c.GL_FRAGMENT_SHADER); + + var ps_code = + \\#version 100 + \\attribute vec3 vPosition; + \\attribute vec3 vNormal; + \\uniform mat4 uTransform; + \\varying vec3 normal; + \\void main() { + \\ normal = mat3(uTransform) * vNormal; + \\ gl_Position = uTransform * vec4(vPosition, 1.0); + \\} + \\ + ; + var fs_code = + \\#version 100 + \\varying highp vec3 normal; + \\void main() { + \\ highp vec3 base_color = vec3(0.968,0.643,0.113); // #F7A41D + \\ highp vec3 ldir = normalize(vec3(0.3, 0.4, 2.0)); + \\ highp float l = 0.3 + 0.8 * clamp(-dot(normal, ldir), 0.0, 1.0); + \\ gl_FragColor = vec4(l * base_color,1); + \\} + \\ + ; + + c.glShaderSource(ps, 1, @as([*c]const [*c]const u8, @ptrCast(&ps_code)), null); + c.glShaderSource(fs, 1, @as([*c]const [*c]const u8, @ptrCast(&fs_code)), null); + + c.glCompileShader(ps); + c.glCompileShader(fs); + + glShaderInfoLog(ps); + glShaderInfoLog(fs); + + c.glAttachShader(shaded_program, ps); + c.glAttachShader(shaded_program, fs); + + c.glBindAttribLocation(shaded_program, 0, "vPosition"); + c.glBindAttribLocation(shaded_program, 1, "vNormal"); + c.glLinkProgram(shaded_program); + + c.glDetachShader(shaded_program, ps); + c.glDetachShader(shaded_program, fs); + + glProgramInfoLog(shaded_program); + } + + uTransform = c.glGetUniformLocation(shaded_program, "uTransform"); + + // Get attrib locations + const mesh_vPosition_res = c.glGetAttribLocation(shaded_program, "vPosition"); + app_log.info("mesh_vPosition: {}", .{mesh_vPosition_res}); + mesh_vPosition = @as(c.GLuint, @intCast(mesh_vPosition_res)); + const mesh_vNormal_res = c.glGetAttribLocation(shaded_program, "vNormal"); + app_log.info("mesh_vNormal: {}", .{mesh_vNormal_res}); + mesh_vNormal = @as(c.GLuint, @intCast(mesh_vNormal_res)); + + // Bind the vertices to the buffer + c.glGenBuffers(1, &mesh_buffer); + c.glBindBuffer(c.GL_ARRAY_BUFFER, mesh_buffer); + c.glBufferData(c.GL_ARRAY_BUFFER, @as(isize, @intCast(mesh.len * @sizeOf(MeshVertex))), &mesh, c.GL_STATIC_DRAW); + + self.egl_init = false; + } + + const t = @as(f32, @floatFromInt(loop)) / 100.0; + + // Clear the screen + c.glClearColor( + 0.5 + 0.5 * @sin(t + 0.0), + 0.5 + 0.5 * @sin(t + 1.0), + 0.5 + 0.5 * @sin(t + 2.0), + 1.0, + ); + c.glClear(c.GL_COLOR_BUFFER_BIT); + + // -- Start touch display code + c.glUseProgram(touch_program); + + c.glBindBuffer(c.GL_ARRAY_BUFFER, touch_buffer); + + c.glEnableVertexAttribArray(vPosition); + c.glVertexAttribPointer(vPosition, 2, c.GL_FLOAT, c.GL_FALSE, 0, @as(?*anyopaque, @ptrFromInt(0))); + + // c.glDisableVertexAttribArray(1); + + c.glDisable(c.GL_DEPTH_TEST); + c.glEnable(c.GL_BLEND); + c.glBlendFunc(c.GL_ONE, c.GL_ONE); + c.glBlendEquation(c.GL_FUNC_ADD); + + for (&self.touch_points) |*pt| { + if (pt.*) |*point| { + c.glUniform1f(uAspect, self.screen_width / self.screen_height); + c.glUniform2f(uPos, point.x / self.screen_width, 1.0 - point.y / self.screen_height); + c.glUniform1f(uIntensity, point.intensity); + c.glDrawArrays(c.GL_TRIANGLE_STRIP, 0, 4); + + point.intensity -= 0.05; + if (point.intensity <= 0.0) { + // if (point.index) |index| { + // self.simple_synth.oscillators[@as(usize, @intCast(index))].setWaveOn(false); + // } + pt.* = null; + } + } + } + glDrainErrors(); + + // -- Start 3d zig logo code + c.glBindBuffer(c.GL_ARRAY_BUFFER, mesh_buffer); + c.glEnableVertexAttribArray(mesh_vPosition); + c.glVertexAttribPointer(mesh_vPosition, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @as(?*anyopaque, @ptrFromInt(@offsetOf(MeshVertex, "pos")))); + + c.glEnableVertexAttribArray(mesh_vNormal); + c.glVertexAttribPointer(mesh_vNormal, 3, c.GL_FLOAT, c.GL_FALSE, @sizeOf(MeshVertex), @as(?*anyopaque, @ptrFromInt(@offsetOf(MeshVertex, "normal")))); + + c.glUseProgram(shaded_program); + + c.glClearDepthf(1.0); + c.glClear(c.GL_DEPTH_BUFFER_BIT); + + c.glDisable(c.GL_BLEND); + c.glEnable(c.GL_DEPTH_TEST); + + var matrix = [4][4]f32{ + [4]f32{ 1, 0, 0, 0 }, + [4]f32{ 0, 1, 0, 0 }, + [4]f32{ 0, 0, 1, 0 }, + [4]f32{ 0, 0, 0, 1 }, + }; + + matrix[1][1] = self.screen_width / self.screen_height; + + matrix[0][0] = @sin(t); + matrix[2][0] = @cos(t); + matrix[0][2] = @cos(t); + matrix[2][2] = -@sin(t); + + c.glUniformMatrix4fv(uTransform, 1, c.GL_FALSE, @as([*]const f32, @ptrCast(&matrix))); + + c.glDrawArrays(c.GL_TRIANGLES, 0, mesh.len); + + glDrainErrors(); + + try egl.swapBuffers(); + } + } + loop += 1; + + std.time.sleep(10 * std.time.ns_per_ms); + } + app_log.info("mainLoop() finished\n", .{}); + } +}; + +const MeshVertex = extern struct { + pos: Vector4, + normal: Vector4, +}; + +const Vector4 = extern struct { + x: f32, + y: f32, + z: f32, + w: f32 = 1.0, + + fn readFromSlice(slice: []const u8) Vector4 { + return Vector4{ + .x = @as(f32, @bitCast(std.mem.readInt(u32, slice[0..4], .little))), + .y = @as(f32, @bitCast(std.mem.readInt(u32, slice[4..8], .little))), + .z = @as(f32, @bitCast(std.mem.readInt(u32, slice[8..12], .little))), + .w = 1.0, + }; + } +}; + +const mesh = blk: { + const stl_data = @embedFile("logo.stl"); + + const count = std.mem.readInt(u32, stl_data[80..][0..4], .little); + + var slice: []const u8 = stl_data[84..]; + + var array: [3 * count]MeshVertex = undefined; + var index: usize = 0; + + @setEvalBranchQuota(10_000); + + while (index < count) : (index += 1) { + const normal = Vector4.readFromSlice(slice[0..]); + const v1 = Vector4.readFromSlice(slice[12..]); + const v2 = Vector4.readFromSlice(slice[24..]); + const v3 = Vector4.readFromSlice(slice[36..]); + const attrib_count = std.mem.readInt(u16, slice[48..50], .little); + + array[3 * index + 0] = MeshVertex{ + .pos = v1, + .normal = normal, + }; + array[3 * index + 1] = MeshVertex{ + .pos = v2, + .normal = normal, + }; + array[3 * index + 2] = MeshVertex{ + .pos = v3, + .normal = normal, + }; + + slice = slice[50 + attrib_count ..]; + } + + break :blk array; +}; + +pub fn glProgramInfoLog(program: c.GLuint) void { + var buffer: [4096]u8 = undefined; + var size: c.GLsizei = undefined; + c.glGetProgramInfoLog(program, 4096, &size, &buffer); + if (size == 0) return; + app_log.info("{s}", .{buffer[0..@as(usize, @intCast(size))]}); +} + +pub fn glShaderInfoLog(shader: c.GLuint) void { + var buffer: [4096]u8 = undefined; + var size: c.GLsizei = undefined; + c.glGetShaderInfoLog(shader, 4096, &size, &buffer); + if (size == 0) return; + app_log.info("{s}", .{buffer[0..@as(usize, @intCast(size))]}); +} + +pub fn glCheckError(res: i64) void { + switch (res) { + c.GL_INVALID_ENUM => app_log.err("GL error code {}: Invalid enum", .{res}), + c.GL_INVALID_VALUE => app_log.err("GL error code {}: Invalid value", .{res}), + c.GL_INVALID_OPERATION => app_log.err("GL error code {}: Invalid operation", .{res}), + // c.GL_STACK_OVERFLOW => app_log.err("GL error code {}: Stack overflow", .{res}), + // c.GL_STACK_UNDERFLOW => app_log.err("GL error code {}: Stack underflow", .{res}), + c.GL_OUT_OF_MEMORY => app_log.err("GL error code {}: Out of memory", .{res}), + // c.GL_TABLE_TOO_LARGE => app_log.err("GL error code {}: Table too large", .{res}), + c.GL_NO_ERROR => {}, + else => {}, + } +} + +pub fn glDrainErrors() void { + var res = c.glGetError(); + while (res != c.GL_NO_ERROR) : (res = c.glGetError()) { + glCheckError(res); + } +} + +pub fn enableDebug() void { + const extensions = std.mem.span(c.glGetString(c.GL_EXTENSIONS)); + if (std.mem.indexOf(u8, extensions, "GL_KHR_debug") != null) { + c.glEnable(c.GL_DEBUG_OUTPUT_KHR); + c.glEnable(c.GL_DEBUG_OUTPUT_SYNCHRONOUS_KHR); + + const glDebugMessageControl = @as(c.PFNGLDEBUGMESSAGECONTROLKHRPROC, @ptrCast(c.eglGetProcAddress("glDebugMessageControl"))).?; + glDebugMessageControl(c.GL_DONT_CARE, c.GL_DONT_CARE, c.GL_DEBUG_SEVERITY_NOTIFICATION_KHR, 0, null, c.GL_TRUE); + + const glDebugMessageCallback = @as(c.PFNGLDEBUGMESSAGECALLBACKKHRPROC, @ptrCast(c.eglGetProcAddress("glDebugMessageCallback"))).?; + glDebugMessageCallback(debugMessageCallback, null); + } else { + app_log.err("Debug is not supported.", .{}); + } +} + +pub fn debugMessageCallback( + source: c.GLenum, + logtype: c.GLenum, + id: c.GLuint, + severity: c.GLenum, + length: c.GLsizei, + message_c: ?[*]const c.GLchar, + user_param: ?*const anyopaque, +) callconv(.C) void { + _ = user_param; + const message = message: { + if (message_c) |message_ptr| { + break :message if (length > 0) message_ptr[0..@as(usize, @intCast(length))] else ""; + } else { + break :message ""; + } + }; + const logtype_str = switch (logtype) { + c.GL_DEBUG_TYPE_ERROR_KHR => "Error", + c.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR => "Deprecated Behavior", + c.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR => "Undefined Behavior", + c.GL_DEBUG_TYPE_PORTABILITY_KHR => "Portability", + c.GL_DEBUG_TYPE_PERFORMANCE_KHR => "Performance", + c.GL_DEBUG_TYPE_OTHER_KHR => "Other", + c.GL_DEBUG_TYPE_MARKER_KHR => "Marker", + else => "Unknown/invalid type", + }; + app_log.err("source = {}, type = {s}, id = {}, severity = {}, message = {s}", .{ source, logtype_str, id, severity, message }); +} + +const Oscillator = struct { + isWaveOn: bool = false, + phase: f64 = 0.0, + phaseIncrement: f64 = 0, + frequency: f64 = 440, + amplitude: f64 = 0.1, + + fn setWaveOn(self: *@This(), isWaveOn: bool) void { + @atomicStore(bool, &self.isWaveOn, isWaveOn, .SeqCst); + } + + fn setSampleRate(self: *@This(), sample_rate: i32) void { + self.phaseIncrement = (std.math.tau * self.frequency) / @as(f64, @floatFromInt(sample_rate)); + } + + fn renderf32(self: *@This(), audio_data: []f32) void { + if (!@atomicLoad(bool, &self.isWaveOn, .SeqCst)) self.phase = 0; + + for (audio_data) |*frame| { + if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { + frame.* += @as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)); + self.phase += self.phaseIncrement; + if (self.phase > std.math.tau) self.phase -= std.math.tau; + } + } + } + + fn renderi16(self: *@This(), audio_data: []i16) void { + if (!@atomicLoad(bool, &self.isWaveOn, .SeqCst)) self.phase = 0; + + for (audio_data) |*frame| { + if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { + frame.* +|= @as(i16, @intFromFloat(@as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)) * std.math.maxInt(i16))); + self.phase += self.phaseIncrement; + if (self.phase > std.math.tau) self.phase -= std.math.tau; + } + } + } +}; + +// const SimpleSynth = struct { +// oscillators: [10]Oscillator = [1]Oscillator{.{}} ** 10, + +// fn init() SimpleSynth { +// var synth = SimpleSynth{}; +// for (&synth.oscillators, 0..) |*osc, index| { +// osc.* = Oscillator{ +// .frequency = audio.midiToFreq(49 + index * 3), +// .amplitude = audio.dBToAmplitude(-@as(f64, @floatFromInt(index)) - 15), +// }; +// } +// return synth; +// } + +// fn audioCallback(stream: audio.StreamLayout, user_data: *anyopaque) void { +// var synth = @as(*SimpleSynth, @ptrCast(@alignCast(user_data))); +// std.debug.assert(stream.buffer == .Int16); + +// for (&synth.oscillators) |*osc| { +// osc.setSampleRate(@as(i32, @intCast(stream.sample_rate))); +// osc.renderi16(stream.buffer.Int16); +// } +// } +// }; diff --git a/src/NativeActivity.zig b/src/NativeActivity.zig index c2ec704..c5e1b74 100644 --- a/src/NativeActivity.zig +++ b/src/NativeActivity.zig @@ -17,13 +17,13 @@ pub fn init(activity: *android.ANativeActivity) Self { /// Get the JNIEnv associated with the current thread. pub fn get(activity: *android.ANativeActivity) Self { var env: *android.JNIEnv = undefined; - _ = activity.vm.*.GetEnv(activity.vm, @ptrCast(*?*anyopaque, &env), android.JNI_VERSION_1_6); + _ = activity.vm.*.GetEnv(activity.vm, @as(*?*anyopaque, @ptrCast(&env)), android.JNI_VERSION_1_6); return fromJniEnv(activity, env); } fn fromJniEnv(activity: *android.ANativeActivity, env: *android.JNIEnv) Self { - var jni = @ptrCast(*android.JNI, env); - var activityClass = jni.findClass("android/app/NativeActivity") catch @panic("Could not get NativeActivity class"); + var jni = @as(*android.JNI, @ptrCast(env)); + const activityClass = jni.findClass("android/app/NativeActivity") catch @panic("Could not get NativeActivity class"); return Self{ .activity = activity, @@ -46,7 +46,7 @@ pub fn AndroidGetUnicodeChar(self: *Self, keyCode: c_int, metaState: c_int) !u21 const event_obj = try KeyEvent.newObject("(II)V", .{ eventType, keyCode }); const unicode_key = try KeyEvent.callIntMethod(event_obj, "getUnicodeChar", "(I)I", .{metaState}); - return @intCast(u21, unicode_key); + return @as(u21, @intCast(unicode_key)); } pub fn AndroidMakeFullscreen(self: *Self) !void { @@ -97,7 +97,7 @@ pub fn AndroidMakeFullscreen(self: *Self) !void { pub fn AndroidDisplayKeyboard(self: *Self, show: bool) !bool { // Based on // https://stackoverflow.com/questions/5864790/how-to-show-the-soft-keyboard-on-native-activity - var lFlags: android.jint = 0; + const lFlags: android.jint = 0; // Retrieves Context.INPUT_METHOD_SERVICE. const ClassContext = try self.jni.findClass("android/content/Context"); diff --git a/src/NativeInvocationHandler.zig b/src/NativeInvocationHandler.zig index 4325240..f5ea5bb 100644 --- a/src/NativeInvocationHandler.zig +++ b/src/NativeInvocationHandler.zig @@ -22,14 +22,14 @@ pub fn init(jni: *android.JNI, class: android.jobject) !Self { pub fn createAlloc(self: Self, jni: *android.JNI, alloc: std.mem.Allocator, pointer: ?*anyopaque, function: InvokeFn) !android.jobject { // Create a InvocationHandler struct - var handler = try alloc.create(InvocationHandler); + const handler = try alloc.create(InvocationHandler); errdefer alloc.destroy(handler); handler.* = .{ .pointer = pointer, .function = function, }; - const handler_value = @ptrToInt(handler); + const handler_value = @intFromPtr(handler); std.debug.assert(handler_value <= 0x7fffffffffffffff); // Call handler constructor @@ -59,7 +59,7 @@ const InvocationHandler = struct { const Class = try jni.invokeJni(.GetObjectClass, .{this}); const ptrField = try jni.invokeJni(.GetFieldID, .{ Class, "ptr", "J" }); const jptr = try jni.getLongField(this, ptrField); - const h = @intToPtr(*InvocationHandler, @intCast(usize, jptr)); + const h = @as(*InvocationHandler, @ptrFromInt(jptr)); return h.function(h.pointer, jni, method, args); } }; diff --git a/src/aaudio.zig b/src/aaudio.zig index 56af2c8..1d02463 100644 --- a/src/aaudio.zig +++ b/src/aaudio.zig @@ -36,18 +36,18 @@ pub const AAudio = struct { num_frames: i32, ) callconv(.C) c.aaudio_data_callback_result_t { _ = stream; - const output_stream = @ptrCast(*OutputStream, @alignCast(@alignOf(OutputStream), user_data.?)); + const output_stream = @as(*OutputStream, @ptrCast(@alignCast(user_data.?))); // TODO: // const audio_slice = @ptrCast([*]f32, @alignCast(@alignOf(f32), audio_data.?))[0..@intCast(usize, num_frames)]; - const audio_slice = @ptrCast([*]i16, @alignCast(@alignOf(i16), audio_data.?))[0..@intCast(usize, num_frames)]; + const audio_slice = @as([*]i16, @ptrCast(@alignCast(audio_data.?)))[0..@as(usize, @intCast(num_frames))]; for (audio_slice) |*frame| { frame.* = 0; } - var stream_layout = StreamLayout{ + const stream_layout = StreamLayout{ .sample_rate = output_stream.config.sample_rate.?, - .channel_count = @intCast(usize, output_stream.config.channel_count), + .channel_count = @as(usize, @intCast(output_stream.config.channel_count)), .buffer = .{ .Int16 = audio_slice }, }; @@ -64,7 +64,7 @@ pub const AAudio = struct { _ = stream; audio_log.err("AAudio Stream error! {}", .{err}); if (err == c.AAUDIO_ERROR_DISCONNECTED) { - const output_stream = @ptrCast(*OutputStream, @alignCast(@alignOf(OutputStream), user_data.?)); + const output_stream = @as(*OutputStream, @ptrCast(@alignCast(user_data.?))); _ = std.Thread.spawn(.{}, OutputStream.deinit, .{output_stream}) catch @panic("Error starting thread for AAudioOutputStream"); } } @@ -94,13 +94,13 @@ pub const AAudio = struct { .Int16 => c.AAUDIO_FORMAT_PCM_I16, .Float32 => c.AAUDIO_FORMAT_PCM_FLOAT, }); - c.AAudioStreamBuilder_setChannelCount(stream_builder, @intCast(i32, config.channel_count)); + c.AAudioStreamBuilder_setChannelCount(stream_builder, @as(i32, @intCast(config.channel_count))); c.AAudioStreamBuilder_setPerformanceMode(stream_builder, c.AAUDIO_PERFORMANCE_MODE_LOW_LATENCY); c.AAudioStreamBuilder_setDataCallback(stream_builder, dataCallback, output_stream); c.AAudioStreamBuilder_setErrorCallback(stream_builder, errorCallback, output_stream); - if (config.sample_rate) |rate| c.AAudioStreamBuilder_setSampleRate(stream_builder, @intCast(i32, rate)); - if (config.buffer_size) |size| c.AAudioStreamBuilder_setFramesPerDataCallback(stream_builder, @intCast(i32, size)); + if (config.sample_rate) |rate| c.AAudioStreamBuilder_setSampleRate(stream_builder, @as(i32, @intCast(rate))); + if (config.buffer_size) |size| c.AAudioStreamBuilder_setFramesPerDataCallback(stream_builder, @as(i32, @intCast(size))); // Open the stream checkResult(c.AAudioStreamBuilder_openStream(stream_builder, &output_stream.stream)) catch |e| { @@ -109,10 +109,10 @@ pub const AAudio = struct { }; // Save the details of the stream - output_stream.config.sample_rate = @intCast(u32, c.AAudioStream_getSampleRate(output_stream.stream)); - output_stream.config.buffer_size = @intCast(usize, c.AAudioStream_getFramesPerBurst(output_stream.stream)); + output_stream.config.sample_rate = @as(u32, @intCast(c.AAudioStream_getSampleRate(output_stream.stream))); + output_stream.config.buffer_size = @as(usize, @intCast(c.AAudioStream_getFramesPerBurst(output_stream.stream))); - var res = c.AAudioStream_setBufferSizeInFrames(output_stream.stream, @intCast(i32, output_stream.config.buffer_count * output_stream.config.buffer_size.?)); + const res = c.AAudioStream_setBufferSizeInFrames(output_stream.stream, @as(i32, @intCast(output_stream.config.buffer_count * output_stream.config.buffer_size.?))); if (res < 0) { checkResult(res) catch |e| { audio_log.err("Issue with setting buffer size in frames stream: {s}", .{@errorName(e)}); diff --git a/src/android-bind.zig b/src/android-bind.zig index af1b38e..89eb7cf 100644 --- a/src/android-bind.zig +++ b/src/android-bind.zig @@ -4,15 +4,15 @@ const __builtin_va_list = extern struct { pub const va_list = __builtin_va_list; pub const __gnuc_va_list = __builtin_va_list; -pub const ANDROID_LOG_UNKNOWN = @enumToInt(enum_android_LogPriority.ANDROID_LOG_UNKNOWN); -pub const ANDROID_LOG_DEFAULT = @enumToInt(enum_android_LogPriority.ANDROID_LOG_DEFAULT); -pub const ANDROID_LOG_VERBOSE = @enumToInt(enum_android_LogPriority.ANDROID_LOG_VERBOSE); -pub const ANDROID_LOG_DEBUG = @enumToInt(enum_android_LogPriority.ANDROID_LOG_DEBUG); -pub const ANDROID_LOG_INFO = @enumToInt(enum_android_LogPriority.ANDROID_LOG_INFO); -pub const ANDROID_LOG_WARN = @enumToInt(enum_android_LogPriority.ANDROID_LOG_WARN); -pub const ANDROID_LOG_ERROR = @enumToInt(enum_android_LogPriority.ANDROID_LOG_ERROR); -pub const ANDROID_LOG_FATAL = @enumToInt(enum_android_LogPriority.ANDROID_LOG_FATAL); -pub const ANDROID_LOG_SILENT = @enumToInt(enum_android_LogPriority.ANDROID_LOG_SILENT); +pub const ANDROID_LOG_UNKNOWN = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_UNKNOWN); +pub const ANDROID_LOG_DEFAULT = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_DEFAULT); +pub const ANDROID_LOG_VERBOSE = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_VERBOSE); +pub const ANDROID_LOG_DEBUG = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_DEBUG); +pub const ANDROID_LOG_INFO = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_INFO); +pub const ANDROID_LOG_WARN = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_WARN); +pub const ANDROID_LOG_ERROR = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_ERROR); +pub const ANDROID_LOG_FATAL = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_FATAL); +pub const ANDROID_LOG_SILENT = @intFromEnum(enum_android_LogPriority.ANDROID_LOG_SILENT); pub const enum_android_LogPriority = enum(c_int) { ANDROID_LOG_UNKNOWN = 0, ANDROID_LOG_DEFAULT = 1, @@ -30,16 +30,16 @@ pub extern fn __android_log_write(prio: c_int, tag: [*c]const u8, text: [*c]cons pub extern fn __android_log_print(prio: c_int, tag: [*c]const u8, fmt: [*c]const u8, ...) c_int; pub extern fn __android_log_vprint(prio: c_int, tag: [*c]const u8, fmt: [*c]const u8, ap: va_list) c_int; pub extern fn __android_log_assert(cond: [*c]const u8, tag: [*c]const u8, fmt: [*c]const u8, ...) noreturn; -pub const LOG_ID_MIN = @enumToInt(enum_log_id.LOG_ID_MIN); -pub const LOG_ID_MAIN = @enumToInt(enum_log_id.LOG_ID_MAIN); -pub const LOG_ID_RADIO = @enumToInt(enum_log_id.LOG_ID_RADIO); -pub const LOG_ID_EVENTS = @enumToInt(enum_log_id.LOG_ID_EVENTS); -pub const LOG_ID_SYSTEM = @enumToInt(enum_log_id.LOG_ID_SYSTEM); -pub const LOG_ID_CRASH = @enumToInt(enum_log_id.LOG_ID_CRASH); -pub const LOG_ID_STATS = @enumToInt(enum_log_id.LOG_ID_STATS); -pub const LOG_ID_SECURITY = @enumToInt(enum_log_id.LOG_ID_SECURITY); -pub const LOG_ID_KERNEL = @enumToInt(enum_log_id.LOG_ID_KERNEL); -pub const LOG_ID_MAX = @enumToInt(enum_log_id.LOG_ID_MAX); +pub const LOG_ID_MIN = @intFromEnum(enum_log_id.LOG_ID_MIN); +pub const LOG_ID_MAIN = @intFromEnum(enum_log_id.LOG_ID_MAIN); +pub const LOG_ID_RADIO = @intFromEnum(enum_log_id.LOG_ID_RADIO); +pub const LOG_ID_EVENTS = @intFromEnum(enum_log_id.LOG_ID_EVENTS); +pub const LOG_ID_SYSTEM = @intFromEnum(enum_log_id.LOG_ID_SYSTEM); +pub const LOG_ID_CRASH = @intFromEnum(enum_log_id.LOG_ID_CRASH); +pub const LOG_ID_STATS = @intFromEnum(enum_log_id.LOG_ID_STATS); +pub const LOG_ID_SECURITY = @intFromEnum(enum_log_id.LOG_ID_SECURITY); +pub const LOG_ID_KERNEL = @intFromEnum(enum_log_id.LOG_ID_KERNEL); +pub const LOG_ID_MAX = @intFromEnum(enum_log_id.LOG_ID_MAX); pub const enum_log_id = enum(c_int) { LOG_ID_MIN = 0, LOG_ID_MAIN = 0, @@ -240,10 +240,10 @@ pub const u_int64_t = u64; pub const AAssetManager = opaque {}; pub const AAssetDir = opaque {}; pub const AAsset = opaque {}; -pub const AASSET_MODE_UNKNOWN = @enumToInt(enum_unnamed_10.AASSET_MODE_UNKNOWN); -pub const AASSET_MODE_RANDOM = @enumToInt(enum_unnamed_10.AASSET_MODE_RANDOM); -pub const AASSET_MODE_STREAMING = @enumToInt(enum_unnamed_10.AASSET_MODE_STREAMING); -pub const AASSET_MODE_BUFFER = @enumToInt(enum_unnamed_10.AASSET_MODE_BUFFER); +pub const AASSET_MODE_UNKNOWN = @intFromEnum(enum_unnamed_10.AASSET_MODE_UNKNOWN); +pub const AASSET_MODE_RANDOM = @intFromEnum(enum_unnamed_10.AASSET_MODE_RANDOM); +pub const AASSET_MODE_STREAMING = @intFromEnum(enum_unnamed_10.AASSET_MODE_STREAMING); +pub const AASSET_MODE_BUFFER = @intFromEnum(enum_unnamed_10.AASSET_MODE_BUFFER); const enum_unnamed_10 = enum(c_int) { AASSET_MODE_UNKNOWN = 0, AASSET_MODE_RANDOM = 1, @@ -409,16 +409,16 @@ pub extern fn AConfiguration_isBetterThan(base: ?*AConfiguration, @"test": ?*ACo pub const struct_ALooper = opaque {}; pub const ALooper = struct_ALooper; pub extern fn ALooper_forThread(...) ?*ALooper; -pub const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS = @enumToInt(enum_unnamed_12.ALOOPER_PREPARE_ALLOW_NON_CALLBACKS); +pub const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS = @intFromEnum(enum_unnamed_12.ALOOPER_PREPARE_ALLOW_NON_CALLBACKS); const enum_unnamed_12 = enum(c_int) { ALOOPER_PREPARE_ALLOW_NON_CALLBACKS = 1, _, }; pub extern fn ALooper_prepare(opts: c_int) ?*ALooper; -pub const ALOOPER_POLL_WAKE = @enumToInt(enum_unnamed_13.ALOOPER_POLL_WAKE); -pub const ALOOPER_POLL_CALLBACK = @enumToInt(enum_unnamed_13.ALOOPER_POLL_CALLBACK); -pub const ALOOPER_POLL_TIMEOUT = @enumToInt(enum_unnamed_13.ALOOPER_POLL_TIMEOUT); -pub const ALOOPER_POLL_ERROR = @enumToInt(enum_unnamed_13.ALOOPER_POLL_ERROR); +pub const ALOOPER_POLL_WAKE = @intFromEnum(enum_unnamed_13.ALOOPER_POLL_WAKE); +pub const ALOOPER_POLL_CALLBACK = @intFromEnum(enum_unnamed_13.ALOOPER_POLL_CALLBACK); +pub const ALOOPER_POLL_TIMEOUT = @intFromEnum(enum_unnamed_13.ALOOPER_POLL_TIMEOUT); +pub const ALOOPER_POLL_ERROR = @intFromEnum(enum_unnamed_13.ALOOPER_POLL_ERROR); const enum_unnamed_13 = enum(c_int) { ALOOPER_POLL_WAKE = -1, ALOOPER_POLL_CALLBACK = -2, @@ -428,11 +428,11 @@ const enum_unnamed_13 = enum(c_int) { }; pub extern fn ALooper_acquire(looper: ?*ALooper) void; pub extern fn ALooper_release(looper: ?*ALooper) void; -pub const ALOOPER_EVENT_INPUT = @enumToInt(enum_unnamed_14.ALOOPER_EVENT_INPUT); -pub const ALOOPER_EVENT_OUTPUT = @enumToInt(enum_unnamed_14.ALOOPER_EVENT_OUTPUT); -pub const ALOOPER_EVENT_ERROR = @enumToInt(enum_unnamed_14.ALOOPER_EVENT_ERROR); -pub const ALOOPER_EVENT_HANGUP = @enumToInt(enum_unnamed_14.ALOOPER_EVENT_HANGUP); -pub const ALOOPER_EVENT_INVALID = @enumToInt(enum_unnamed_14.ALOOPER_EVENT_INVALID); +pub const ALOOPER_EVENT_INPUT = @intFromEnum(enum_unnamed_14.ALOOPER_EVENT_INPUT); +pub const ALOOPER_EVENT_OUTPUT = @intFromEnum(enum_unnamed_14.ALOOPER_EVENT_OUTPUT); +pub const ALOOPER_EVENT_ERROR = @intFromEnum(enum_unnamed_14.ALOOPER_EVENT_ERROR); +pub const ALOOPER_EVENT_HANGUP = @intFromEnum(enum_unnamed_14.ALOOPER_EVENT_HANGUP); +pub const ALOOPER_EVENT_INVALID = @intFromEnum(enum_unnamed_14.ALOOPER_EVENT_INVALID); const enum_unnamed_14 = enum(c_int) { ALOOPER_EVENT_INPUT = 1, ALOOPER_EVENT_OUTPUT = 2, @@ -497,10 +497,10 @@ pub const union_jvalue = extern union { l: jobject, }; pub const jvalue = union_jvalue; -pub const JNIInvalidRefType = @enumToInt(enum_jobjectRefType.JNIInvalidRefType); -pub const JNILocalRefType = @enumToInt(enum_jobjectRefType.JNILocalRefType); -pub const JNIGlobalRefType = @enumToInt(enum_jobjectRefType.JNIGlobalRefType); -pub const JNIWeakGlobalRefType = @enumToInt(enum_jobjectRefType.JNIWeakGlobalRefType); +pub const JNIInvalidRefType = @intFromEnum(enum_jobjectRefType.JNIInvalidRefType); +pub const JNILocalRefType = @intFromEnum(enum_jobjectRefType.JNILocalRefType); +pub const JNIGlobalRefType = @intFromEnum(enum_jobjectRefType.JNIGlobalRefType); +pub const JNIWeakGlobalRefType = @intFromEnum(enum_jobjectRefType.JNIWeakGlobalRefType); pub const enum_jobjectRefType = enum(c_int) { JNIInvalidRefType = 0, JNILocalRefType = 1, @@ -782,295 +782,295 @@ pub extern fn JNI_CreateJavaVM([*c][*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) jint pub extern fn JNI_GetCreatedJavaVMs([*c][*c]JavaVM, jsize, [*c]jsize) jint; pub extern fn JNI_OnLoad(vm: [*c]JavaVM, reserved: ?*anyopaque) jint; pub extern fn JNI_OnUnload(vm: [*c]JavaVM, reserved: ?*anyopaque) void; -pub const AKEYCODE_UNKNOWN = @enumToInt(enum_unnamed_16.AKEYCODE_UNKNOWN); -pub const AKEYCODE_SOFT_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_SOFT_LEFT); -pub const AKEYCODE_SOFT_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_SOFT_RIGHT); -pub const AKEYCODE_HOME = @enumToInt(enum_unnamed_16.AKEYCODE_HOME); -pub const AKEYCODE_BACK = @enumToInt(enum_unnamed_16.AKEYCODE_BACK); -pub const AKEYCODE_CALL = @enumToInt(enum_unnamed_16.AKEYCODE_CALL); -pub const AKEYCODE_ENDCALL = @enumToInt(enum_unnamed_16.AKEYCODE_ENDCALL); -pub const AKEYCODE_0 = @enumToInt(enum_unnamed_16.AKEYCODE_0); -pub const AKEYCODE_1 = @enumToInt(enum_unnamed_16.AKEYCODE_1); -pub const AKEYCODE_2 = @enumToInt(enum_unnamed_16.AKEYCODE_2); -pub const AKEYCODE_3 = @enumToInt(enum_unnamed_16.AKEYCODE_3); -pub const AKEYCODE_4 = @enumToInt(enum_unnamed_16.AKEYCODE_4); -pub const AKEYCODE_5 = @enumToInt(enum_unnamed_16.AKEYCODE_5); -pub const AKEYCODE_6 = @enumToInt(enum_unnamed_16.AKEYCODE_6); -pub const AKEYCODE_7 = @enumToInt(enum_unnamed_16.AKEYCODE_7); -pub const AKEYCODE_8 = @enumToInt(enum_unnamed_16.AKEYCODE_8); -pub const AKEYCODE_9 = @enumToInt(enum_unnamed_16.AKEYCODE_9); -pub const AKEYCODE_STAR = @enumToInt(enum_unnamed_16.AKEYCODE_STAR); -pub const AKEYCODE_POUND = @enumToInt(enum_unnamed_16.AKEYCODE_POUND); -pub const AKEYCODE_DPAD_UP = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_UP); -pub const AKEYCODE_DPAD_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_DOWN); -pub const AKEYCODE_DPAD_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_LEFT); -pub const AKEYCODE_DPAD_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_RIGHT); -pub const AKEYCODE_DPAD_CENTER = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_CENTER); -pub const AKEYCODE_VOLUME_UP = @enumToInt(enum_unnamed_16.AKEYCODE_VOLUME_UP); -pub const AKEYCODE_VOLUME_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_VOLUME_DOWN); -pub const AKEYCODE_POWER = @enumToInt(enum_unnamed_16.AKEYCODE_POWER); -pub const AKEYCODE_CAMERA = @enumToInt(enum_unnamed_16.AKEYCODE_CAMERA); -pub const AKEYCODE_CLEAR = @enumToInt(enum_unnamed_16.AKEYCODE_CLEAR); -pub const AKEYCODE_A = @enumToInt(enum_unnamed_16.AKEYCODE_A); -pub const AKEYCODE_B = @enumToInt(enum_unnamed_16.AKEYCODE_B); -pub const AKEYCODE_C = @enumToInt(enum_unnamed_16.AKEYCODE_C); -pub const AKEYCODE_D = @enumToInt(enum_unnamed_16.AKEYCODE_D); -pub const AKEYCODE_E = @enumToInt(enum_unnamed_16.AKEYCODE_E); -pub const AKEYCODE_F = @enumToInt(enum_unnamed_16.AKEYCODE_F); -pub const AKEYCODE_G = @enumToInt(enum_unnamed_16.AKEYCODE_G); -pub const AKEYCODE_H = @enumToInt(enum_unnamed_16.AKEYCODE_H); -pub const AKEYCODE_I = @enumToInt(enum_unnamed_16.AKEYCODE_I); -pub const AKEYCODE_J = @enumToInt(enum_unnamed_16.AKEYCODE_J); -pub const AKEYCODE_K = @enumToInt(enum_unnamed_16.AKEYCODE_K); -pub const AKEYCODE_L = @enumToInt(enum_unnamed_16.AKEYCODE_L); -pub const AKEYCODE_M = @enumToInt(enum_unnamed_16.AKEYCODE_M); -pub const AKEYCODE_N = @enumToInt(enum_unnamed_16.AKEYCODE_N); -pub const AKEYCODE_O = @enumToInt(enum_unnamed_16.AKEYCODE_O); -pub const AKEYCODE_P = @enumToInt(enum_unnamed_16.AKEYCODE_P); -pub const AKEYCODE_Q = @enumToInt(enum_unnamed_16.AKEYCODE_Q); -pub const AKEYCODE_R = @enumToInt(enum_unnamed_16.AKEYCODE_R); -pub const AKEYCODE_S = @enumToInt(enum_unnamed_16.AKEYCODE_S); -pub const AKEYCODE_T = @enumToInt(enum_unnamed_16.AKEYCODE_T); -pub const AKEYCODE_U = @enumToInt(enum_unnamed_16.AKEYCODE_U); -pub const AKEYCODE_V = @enumToInt(enum_unnamed_16.AKEYCODE_V); -pub const AKEYCODE_W = @enumToInt(enum_unnamed_16.AKEYCODE_W); -pub const AKEYCODE_X = @enumToInt(enum_unnamed_16.AKEYCODE_X); -pub const AKEYCODE_Y = @enumToInt(enum_unnamed_16.AKEYCODE_Y); -pub const AKEYCODE_Z = @enumToInt(enum_unnamed_16.AKEYCODE_Z); -pub const AKEYCODE_COMMA = @enumToInt(enum_unnamed_16.AKEYCODE_COMMA); -pub const AKEYCODE_PERIOD = @enumToInt(enum_unnamed_16.AKEYCODE_PERIOD); -pub const AKEYCODE_ALT_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_ALT_LEFT); -pub const AKEYCODE_ALT_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_ALT_RIGHT); -pub const AKEYCODE_SHIFT_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_SHIFT_LEFT); -pub const AKEYCODE_SHIFT_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_SHIFT_RIGHT); -pub const AKEYCODE_TAB = @enumToInt(enum_unnamed_16.AKEYCODE_TAB); -pub const AKEYCODE_SPACE = @enumToInt(enum_unnamed_16.AKEYCODE_SPACE); -pub const AKEYCODE_SYM = @enumToInt(enum_unnamed_16.AKEYCODE_SYM); -pub const AKEYCODE_EXPLORER = @enumToInt(enum_unnamed_16.AKEYCODE_EXPLORER); -pub const AKEYCODE_ENVELOPE = @enumToInt(enum_unnamed_16.AKEYCODE_ENVELOPE); -pub const AKEYCODE_ENTER = @enumToInt(enum_unnamed_16.AKEYCODE_ENTER); -pub const AKEYCODE_DEL = @enumToInt(enum_unnamed_16.AKEYCODE_DEL); -pub const AKEYCODE_GRAVE = @enumToInt(enum_unnamed_16.AKEYCODE_GRAVE); -pub const AKEYCODE_MINUS = @enumToInt(enum_unnamed_16.AKEYCODE_MINUS); -pub const AKEYCODE_EQUALS = @enumToInt(enum_unnamed_16.AKEYCODE_EQUALS); -pub const AKEYCODE_LEFT_BRACKET = @enumToInt(enum_unnamed_16.AKEYCODE_LEFT_BRACKET); -pub const AKEYCODE_RIGHT_BRACKET = @enumToInt(enum_unnamed_16.AKEYCODE_RIGHT_BRACKET); -pub const AKEYCODE_BACKSLASH = @enumToInt(enum_unnamed_16.AKEYCODE_BACKSLASH); -pub const AKEYCODE_SEMICOLON = @enumToInt(enum_unnamed_16.AKEYCODE_SEMICOLON); -pub const AKEYCODE_APOSTROPHE = @enumToInt(enum_unnamed_16.AKEYCODE_APOSTROPHE); -pub const AKEYCODE_SLASH = @enumToInt(enum_unnamed_16.AKEYCODE_SLASH); -pub const AKEYCODE_AT = @enumToInt(enum_unnamed_16.AKEYCODE_AT); -pub const AKEYCODE_NUM = @enumToInt(enum_unnamed_16.AKEYCODE_NUM); -pub const AKEYCODE_HEADSETHOOK = @enumToInt(enum_unnamed_16.AKEYCODE_HEADSETHOOK); -pub const AKEYCODE_FOCUS = @enumToInt(enum_unnamed_16.AKEYCODE_FOCUS); -pub const AKEYCODE_PLUS = @enumToInt(enum_unnamed_16.AKEYCODE_PLUS); -pub const AKEYCODE_MENU = @enumToInt(enum_unnamed_16.AKEYCODE_MENU); -pub const AKEYCODE_NOTIFICATION = @enumToInt(enum_unnamed_16.AKEYCODE_NOTIFICATION); -pub const AKEYCODE_SEARCH = @enumToInt(enum_unnamed_16.AKEYCODE_SEARCH); -pub const AKEYCODE_MEDIA_PLAY_PAUSE = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_PLAY_PAUSE); -pub const AKEYCODE_MEDIA_STOP = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_STOP); -pub const AKEYCODE_MEDIA_NEXT = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_NEXT); -pub const AKEYCODE_MEDIA_PREVIOUS = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_PREVIOUS); -pub const AKEYCODE_MEDIA_REWIND = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_REWIND); -pub const AKEYCODE_MEDIA_FAST_FORWARD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_FAST_FORWARD); -pub const AKEYCODE_MUTE = @enumToInt(enum_unnamed_16.AKEYCODE_MUTE); -pub const AKEYCODE_PAGE_UP = @enumToInt(enum_unnamed_16.AKEYCODE_PAGE_UP); -pub const AKEYCODE_PAGE_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_PAGE_DOWN); -pub const AKEYCODE_PICTSYMBOLS = @enumToInt(enum_unnamed_16.AKEYCODE_PICTSYMBOLS); -pub const AKEYCODE_SWITCH_CHARSET = @enumToInt(enum_unnamed_16.AKEYCODE_SWITCH_CHARSET); -pub const AKEYCODE_BUTTON_A = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_A); -pub const AKEYCODE_BUTTON_B = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_B); -pub const AKEYCODE_BUTTON_C = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_C); -pub const AKEYCODE_BUTTON_X = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_X); -pub const AKEYCODE_BUTTON_Y = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_Y); -pub const AKEYCODE_BUTTON_Z = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_Z); -pub const AKEYCODE_BUTTON_L1 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_L1); -pub const AKEYCODE_BUTTON_R1 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_R1); -pub const AKEYCODE_BUTTON_L2 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_L2); -pub const AKEYCODE_BUTTON_R2 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_R2); -pub const AKEYCODE_BUTTON_THUMBL = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_THUMBL); -pub const AKEYCODE_BUTTON_THUMBR = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_THUMBR); -pub const AKEYCODE_BUTTON_START = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_START); -pub const AKEYCODE_BUTTON_SELECT = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_SELECT); -pub const AKEYCODE_BUTTON_MODE = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_MODE); -pub const AKEYCODE_ESCAPE = @enumToInt(enum_unnamed_16.AKEYCODE_ESCAPE); -pub const AKEYCODE_FORWARD_DEL = @enumToInt(enum_unnamed_16.AKEYCODE_FORWARD_DEL); -pub const AKEYCODE_CTRL_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_CTRL_LEFT); -pub const AKEYCODE_CTRL_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_CTRL_RIGHT); -pub const AKEYCODE_CAPS_LOCK = @enumToInt(enum_unnamed_16.AKEYCODE_CAPS_LOCK); -pub const AKEYCODE_SCROLL_LOCK = @enumToInt(enum_unnamed_16.AKEYCODE_SCROLL_LOCK); -pub const AKEYCODE_META_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_META_LEFT); -pub const AKEYCODE_META_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_META_RIGHT); -pub const AKEYCODE_FUNCTION = @enumToInt(enum_unnamed_16.AKEYCODE_FUNCTION); -pub const AKEYCODE_SYSRQ = @enumToInt(enum_unnamed_16.AKEYCODE_SYSRQ); -pub const AKEYCODE_BREAK = @enumToInt(enum_unnamed_16.AKEYCODE_BREAK); -pub const AKEYCODE_MOVE_HOME = @enumToInt(enum_unnamed_16.AKEYCODE_MOVE_HOME); -pub const AKEYCODE_MOVE_END = @enumToInt(enum_unnamed_16.AKEYCODE_MOVE_END); -pub const AKEYCODE_INSERT = @enumToInt(enum_unnamed_16.AKEYCODE_INSERT); -pub const AKEYCODE_FORWARD = @enumToInt(enum_unnamed_16.AKEYCODE_FORWARD); -pub const AKEYCODE_MEDIA_PLAY = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_PLAY); -pub const AKEYCODE_MEDIA_PAUSE = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_PAUSE); -pub const AKEYCODE_MEDIA_CLOSE = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_CLOSE); -pub const AKEYCODE_MEDIA_EJECT = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_EJECT); -pub const AKEYCODE_MEDIA_RECORD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_RECORD); -pub const AKEYCODE_F1 = @enumToInt(enum_unnamed_16.AKEYCODE_F1); -pub const AKEYCODE_F2 = @enumToInt(enum_unnamed_16.AKEYCODE_F2); -pub const AKEYCODE_F3 = @enumToInt(enum_unnamed_16.AKEYCODE_F3); -pub const AKEYCODE_F4 = @enumToInt(enum_unnamed_16.AKEYCODE_F4); -pub const AKEYCODE_F5 = @enumToInt(enum_unnamed_16.AKEYCODE_F5); -pub const AKEYCODE_F6 = @enumToInt(enum_unnamed_16.AKEYCODE_F6); -pub const AKEYCODE_F7 = @enumToInt(enum_unnamed_16.AKEYCODE_F7); -pub const AKEYCODE_F8 = @enumToInt(enum_unnamed_16.AKEYCODE_F8); -pub const AKEYCODE_F9 = @enumToInt(enum_unnamed_16.AKEYCODE_F9); -pub const AKEYCODE_F10 = @enumToInt(enum_unnamed_16.AKEYCODE_F10); -pub const AKEYCODE_F11 = @enumToInt(enum_unnamed_16.AKEYCODE_F11); -pub const AKEYCODE_F12 = @enumToInt(enum_unnamed_16.AKEYCODE_F12); -pub const AKEYCODE_NUM_LOCK = @enumToInt(enum_unnamed_16.AKEYCODE_NUM_LOCK); -pub const AKEYCODE_NUMPAD_0 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_0); -pub const AKEYCODE_NUMPAD_1 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_1); -pub const AKEYCODE_NUMPAD_2 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_2); -pub const AKEYCODE_NUMPAD_3 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_3); -pub const AKEYCODE_NUMPAD_4 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_4); -pub const AKEYCODE_NUMPAD_5 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_5); -pub const AKEYCODE_NUMPAD_6 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_6); -pub const AKEYCODE_NUMPAD_7 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_7); -pub const AKEYCODE_NUMPAD_8 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_8); -pub const AKEYCODE_NUMPAD_9 = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_9); -pub const AKEYCODE_NUMPAD_DIVIDE = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_DIVIDE); -pub const AKEYCODE_NUMPAD_MULTIPLY = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_MULTIPLY); -pub const AKEYCODE_NUMPAD_SUBTRACT = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_SUBTRACT); -pub const AKEYCODE_NUMPAD_ADD = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_ADD); -pub const AKEYCODE_NUMPAD_DOT = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_DOT); -pub const AKEYCODE_NUMPAD_COMMA = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_COMMA); -pub const AKEYCODE_NUMPAD_ENTER = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_ENTER); -pub const AKEYCODE_NUMPAD_EQUALS = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_EQUALS); -pub const AKEYCODE_NUMPAD_LEFT_PAREN = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_LEFT_PAREN); -pub const AKEYCODE_NUMPAD_RIGHT_PAREN = @enumToInt(enum_unnamed_16.AKEYCODE_NUMPAD_RIGHT_PAREN); -pub const AKEYCODE_VOLUME_MUTE = @enumToInt(enum_unnamed_16.AKEYCODE_VOLUME_MUTE); -pub const AKEYCODE_INFO = @enumToInt(enum_unnamed_16.AKEYCODE_INFO); -pub const AKEYCODE_CHANNEL_UP = @enumToInt(enum_unnamed_16.AKEYCODE_CHANNEL_UP); -pub const AKEYCODE_CHANNEL_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_CHANNEL_DOWN); -pub const AKEYCODE_ZOOM_IN = @enumToInt(enum_unnamed_16.AKEYCODE_ZOOM_IN); -pub const AKEYCODE_ZOOM_OUT = @enumToInt(enum_unnamed_16.AKEYCODE_ZOOM_OUT); -pub const AKEYCODE_TV = @enumToInt(enum_unnamed_16.AKEYCODE_TV); -pub const AKEYCODE_WINDOW = @enumToInt(enum_unnamed_16.AKEYCODE_WINDOW); -pub const AKEYCODE_GUIDE = @enumToInt(enum_unnamed_16.AKEYCODE_GUIDE); -pub const AKEYCODE_DVR = @enumToInt(enum_unnamed_16.AKEYCODE_DVR); -pub const AKEYCODE_BOOKMARK = @enumToInt(enum_unnamed_16.AKEYCODE_BOOKMARK); -pub const AKEYCODE_CAPTIONS = @enumToInt(enum_unnamed_16.AKEYCODE_CAPTIONS); -pub const AKEYCODE_SETTINGS = @enumToInt(enum_unnamed_16.AKEYCODE_SETTINGS); -pub const AKEYCODE_TV_POWER = @enumToInt(enum_unnamed_16.AKEYCODE_TV_POWER); -pub const AKEYCODE_TV_INPUT = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT); -pub const AKEYCODE_STB_POWER = @enumToInt(enum_unnamed_16.AKEYCODE_STB_POWER); -pub const AKEYCODE_STB_INPUT = @enumToInt(enum_unnamed_16.AKEYCODE_STB_INPUT); -pub const AKEYCODE_AVR_POWER = @enumToInt(enum_unnamed_16.AKEYCODE_AVR_POWER); -pub const AKEYCODE_AVR_INPUT = @enumToInt(enum_unnamed_16.AKEYCODE_AVR_INPUT); -pub const AKEYCODE_PROG_RED = @enumToInt(enum_unnamed_16.AKEYCODE_PROG_RED); -pub const AKEYCODE_PROG_GREEN = @enumToInt(enum_unnamed_16.AKEYCODE_PROG_GREEN); -pub const AKEYCODE_PROG_YELLOW = @enumToInt(enum_unnamed_16.AKEYCODE_PROG_YELLOW); -pub const AKEYCODE_PROG_BLUE = @enumToInt(enum_unnamed_16.AKEYCODE_PROG_BLUE); -pub const AKEYCODE_APP_SWITCH = @enumToInt(enum_unnamed_16.AKEYCODE_APP_SWITCH); -pub const AKEYCODE_BUTTON_1 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_1); -pub const AKEYCODE_BUTTON_2 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_2); -pub const AKEYCODE_BUTTON_3 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_3); -pub const AKEYCODE_BUTTON_4 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_4); -pub const AKEYCODE_BUTTON_5 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_5); -pub const AKEYCODE_BUTTON_6 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_6); -pub const AKEYCODE_BUTTON_7 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_7); -pub const AKEYCODE_BUTTON_8 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_8); -pub const AKEYCODE_BUTTON_9 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_9); -pub const AKEYCODE_BUTTON_10 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_10); -pub const AKEYCODE_BUTTON_11 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_11); -pub const AKEYCODE_BUTTON_12 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_12); -pub const AKEYCODE_BUTTON_13 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_13); -pub const AKEYCODE_BUTTON_14 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_14); -pub const AKEYCODE_BUTTON_15 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_15); -pub const AKEYCODE_BUTTON_16 = @enumToInt(enum_unnamed_16.AKEYCODE_BUTTON_16); -pub const AKEYCODE_LANGUAGE_SWITCH = @enumToInt(enum_unnamed_16.AKEYCODE_LANGUAGE_SWITCH); -pub const AKEYCODE_MANNER_MODE = @enumToInt(enum_unnamed_16.AKEYCODE_MANNER_MODE); -pub const AKEYCODE_3D_MODE = @enumToInt(enum_unnamed_16.AKEYCODE_3D_MODE); -pub const AKEYCODE_CONTACTS = @enumToInt(enum_unnamed_16.AKEYCODE_CONTACTS); -pub const AKEYCODE_CALENDAR = @enumToInt(enum_unnamed_16.AKEYCODE_CALENDAR); -pub const AKEYCODE_MUSIC = @enumToInt(enum_unnamed_16.AKEYCODE_MUSIC); -pub const AKEYCODE_CALCULATOR = @enumToInt(enum_unnamed_16.AKEYCODE_CALCULATOR); -pub const AKEYCODE_ZENKAKU_HANKAKU = @enumToInt(enum_unnamed_16.AKEYCODE_ZENKAKU_HANKAKU); -pub const AKEYCODE_EISU = @enumToInt(enum_unnamed_16.AKEYCODE_EISU); -pub const AKEYCODE_MUHENKAN = @enumToInt(enum_unnamed_16.AKEYCODE_MUHENKAN); -pub const AKEYCODE_HENKAN = @enumToInt(enum_unnamed_16.AKEYCODE_HENKAN); -pub const AKEYCODE_KATAKANA_HIRAGANA = @enumToInt(enum_unnamed_16.AKEYCODE_KATAKANA_HIRAGANA); -pub const AKEYCODE_YEN = @enumToInt(enum_unnamed_16.AKEYCODE_YEN); -pub const AKEYCODE_RO = @enumToInt(enum_unnamed_16.AKEYCODE_RO); -pub const AKEYCODE_KANA = @enumToInt(enum_unnamed_16.AKEYCODE_KANA); -pub const AKEYCODE_ASSIST = @enumToInt(enum_unnamed_16.AKEYCODE_ASSIST); -pub const AKEYCODE_BRIGHTNESS_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_BRIGHTNESS_DOWN); -pub const AKEYCODE_BRIGHTNESS_UP = @enumToInt(enum_unnamed_16.AKEYCODE_BRIGHTNESS_UP); -pub const AKEYCODE_MEDIA_AUDIO_TRACK = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_AUDIO_TRACK); -pub const AKEYCODE_SLEEP = @enumToInt(enum_unnamed_16.AKEYCODE_SLEEP); -pub const AKEYCODE_WAKEUP = @enumToInt(enum_unnamed_16.AKEYCODE_WAKEUP); -pub const AKEYCODE_PAIRING = @enumToInt(enum_unnamed_16.AKEYCODE_PAIRING); -pub const AKEYCODE_MEDIA_TOP_MENU = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_TOP_MENU); -pub const AKEYCODE_11 = @enumToInt(enum_unnamed_16.AKEYCODE_11); -pub const AKEYCODE_12 = @enumToInt(enum_unnamed_16.AKEYCODE_12); -pub const AKEYCODE_LAST_CHANNEL = @enumToInt(enum_unnamed_16.AKEYCODE_LAST_CHANNEL); -pub const AKEYCODE_TV_DATA_SERVICE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_DATA_SERVICE); -pub const AKEYCODE_VOICE_ASSIST = @enumToInt(enum_unnamed_16.AKEYCODE_VOICE_ASSIST); -pub const AKEYCODE_TV_RADIO_SERVICE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_RADIO_SERVICE); -pub const AKEYCODE_TV_TELETEXT = @enumToInt(enum_unnamed_16.AKEYCODE_TV_TELETEXT); -pub const AKEYCODE_TV_NUMBER_ENTRY = @enumToInt(enum_unnamed_16.AKEYCODE_TV_NUMBER_ENTRY); -pub const AKEYCODE_TV_TERRESTRIAL_ANALOG = @enumToInt(enum_unnamed_16.AKEYCODE_TV_TERRESTRIAL_ANALOG); -pub const AKEYCODE_TV_TERRESTRIAL_DIGITAL = @enumToInt(enum_unnamed_16.AKEYCODE_TV_TERRESTRIAL_DIGITAL); -pub const AKEYCODE_TV_SATELLITE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_SATELLITE); -pub const AKEYCODE_TV_SATELLITE_BS = @enumToInt(enum_unnamed_16.AKEYCODE_TV_SATELLITE_BS); -pub const AKEYCODE_TV_SATELLITE_CS = @enumToInt(enum_unnamed_16.AKEYCODE_TV_SATELLITE_CS); -pub const AKEYCODE_TV_SATELLITE_SERVICE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_SATELLITE_SERVICE); -pub const AKEYCODE_TV_NETWORK = @enumToInt(enum_unnamed_16.AKEYCODE_TV_NETWORK); -pub const AKEYCODE_TV_ANTENNA_CABLE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_ANTENNA_CABLE); -pub const AKEYCODE_TV_INPUT_HDMI_1 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_1); -pub const AKEYCODE_TV_INPUT_HDMI_2 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_2); -pub const AKEYCODE_TV_INPUT_HDMI_3 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_3); -pub const AKEYCODE_TV_INPUT_HDMI_4 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_4); -pub const AKEYCODE_TV_INPUT_COMPOSITE_1 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPOSITE_1); -pub const AKEYCODE_TV_INPUT_COMPOSITE_2 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPOSITE_2); -pub const AKEYCODE_TV_INPUT_COMPONENT_1 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPONENT_1); -pub const AKEYCODE_TV_INPUT_COMPONENT_2 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPONENT_2); -pub const AKEYCODE_TV_INPUT_VGA_1 = @enumToInt(enum_unnamed_16.AKEYCODE_TV_INPUT_VGA_1); -pub const AKEYCODE_TV_AUDIO_DESCRIPTION = @enumToInt(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION); -pub const AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP = @enumToInt(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP); -pub const AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN); -pub const AKEYCODE_TV_ZOOM_MODE = @enumToInt(enum_unnamed_16.AKEYCODE_TV_ZOOM_MODE); -pub const AKEYCODE_TV_CONTENTS_MENU = @enumToInt(enum_unnamed_16.AKEYCODE_TV_CONTENTS_MENU); -pub const AKEYCODE_TV_MEDIA_CONTEXT_MENU = @enumToInt(enum_unnamed_16.AKEYCODE_TV_MEDIA_CONTEXT_MENU); -pub const AKEYCODE_TV_TIMER_PROGRAMMING = @enumToInt(enum_unnamed_16.AKEYCODE_TV_TIMER_PROGRAMMING); -pub const AKEYCODE_HELP = @enumToInt(enum_unnamed_16.AKEYCODE_HELP); -pub const AKEYCODE_NAVIGATE_PREVIOUS = @enumToInt(enum_unnamed_16.AKEYCODE_NAVIGATE_PREVIOUS); -pub const AKEYCODE_NAVIGATE_NEXT = @enumToInt(enum_unnamed_16.AKEYCODE_NAVIGATE_NEXT); -pub const AKEYCODE_NAVIGATE_IN = @enumToInt(enum_unnamed_16.AKEYCODE_NAVIGATE_IN); -pub const AKEYCODE_NAVIGATE_OUT = @enumToInt(enum_unnamed_16.AKEYCODE_NAVIGATE_OUT); -pub const AKEYCODE_STEM_PRIMARY = @enumToInt(enum_unnamed_16.AKEYCODE_STEM_PRIMARY); -pub const AKEYCODE_STEM_1 = @enumToInt(enum_unnamed_16.AKEYCODE_STEM_1); -pub const AKEYCODE_STEM_2 = @enumToInt(enum_unnamed_16.AKEYCODE_STEM_2); -pub const AKEYCODE_STEM_3 = @enumToInt(enum_unnamed_16.AKEYCODE_STEM_3); -pub const AKEYCODE_DPAD_UP_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_UP_LEFT); -pub const AKEYCODE_DPAD_DOWN_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_DOWN_LEFT); -pub const AKEYCODE_DPAD_UP_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_UP_RIGHT); -pub const AKEYCODE_DPAD_DOWN_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_DPAD_DOWN_RIGHT); -pub const AKEYCODE_MEDIA_SKIP_FORWARD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_SKIP_FORWARD); -pub const AKEYCODE_MEDIA_SKIP_BACKWARD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_SKIP_BACKWARD); -pub const AKEYCODE_MEDIA_STEP_FORWARD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_STEP_FORWARD); -pub const AKEYCODE_MEDIA_STEP_BACKWARD = @enumToInt(enum_unnamed_16.AKEYCODE_MEDIA_STEP_BACKWARD); -pub const AKEYCODE_SOFT_SLEEP = @enumToInt(enum_unnamed_16.AKEYCODE_SOFT_SLEEP); -pub const AKEYCODE_CUT = @enumToInt(enum_unnamed_16.AKEYCODE_CUT); -pub const AKEYCODE_COPY = @enumToInt(enum_unnamed_16.AKEYCODE_COPY); -pub const AKEYCODE_PASTE = @enumToInt(enum_unnamed_16.AKEYCODE_PASTE); -pub const AKEYCODE_SYSTEM_NAVIGATION_UP = @enumToInt(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_UP); -pub const AKEYCODE_SYSTEM_NAVIGATION_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_DOWN); -pub const AKEYCODE_SYSTEM_NAVIGATION_LEFT = @enumToInt(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_LEFT); -pub const AKEYCODE_SYSTEM_NAVIGATION_RIGHT = @enumToInt(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_RIGHT); -pub const AKEYCODE_ALL_APPS = @enumToInt(enum_unnamed_16.AKEYCODE_ALL_APPS); -pub const AKEYCODE_REFRESH = @enumToInt(enum_unnamed_16.AKEYCODE_REFRESH); -pub const AKEYCODE_THUMBS_UP = @enumToInt(enum_unnamed_16.AKEYCODE_THUMBS_UP); -pub const AKEYCODE_THUMBS_DOWN = @enumToInt(enum_unnamed_16.AKEYCODE_THUMBS_DOWN); -pub const AKEYCODE_PROFILE_SWITCH = @enumToInt(enum_unnamed_16.AKEYCODE_PROFILE_SWITCH); +pub const AKEYCODE_UNKNOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_UNKNOWN); +pub const AKEYCODE_SOFT_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_SOFT_LEFT); +pub const AKEYCODE_SOFT_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_SOFT_RIGHT); +pub const AKEYCODE_HOME = @intFromEnum(enum_unnamed_16.AKEYCODE_HOME); +pub const AKEYCODE_BACK = @intFromEnum(enum_unnamed_16.AKEYCODE_BACK); +pub const AKEYCODE_CALL = @intFromEnum(enum_unnamed_16.AKEYCODE_CALL); +pub const AKEYCODE_ENDCALL = @intFromEnum(enum_unnamed_16.AKEYCODE_ENDCALL); +pub const AKEYCODE_0 = @intFromEnum(enum_unnamed_16.AKEYCODE_0); +pub const AKEYCODE_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_1); +pub const AKEYCODE_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_2); +pub const AKEYCODE_3 = @intFromEnum(enum_unnamed_16.AKEYCODE_3); +pub const AKEYCODE_4 = @intFromEnum(enum_unnamed_16.AKEYCODE_4); +pub const AKEYCODE_5 = @intFromEnum(enum_unnamed_16.AKEYCODE_5); +pub const AKEYCODE_6 = @intFromEnum(enum_unnamed_16.AKEYCODE_6); +pub const AKEYCODE_7 = @intFromEnum(enum_unnamed_16.AKEYCODE_7); +pub const AKEYCODE_8 = @intFromEnum(enum_unnamed_16.AKEYCODE_8); +pub const AKEYCODE_9 = @intFromEnum(enum_unnamed_16.AKEYCODE_9); +pub const AKEYCODE_STAR = @intFromEnum(enum_unnamed_16.AKEYCODE_STAR); +pub const AKEYCODE_POUND = @intFromEnum(enum_unnamed_16.AKEYCODE_POUND); +pub const AKEYCODE_DPAD_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_UP); +pub const AKEYCODE_DPAD_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_DOWN); +pub const AKEYCODE_DPAD_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_LEFT); +pub const AKEYCODE_DPAD_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_RIGHT); +pub const AKEYCODE_DPAD_CENTER = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_CENTER); +pub const AKEYCODE_VOLUME_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_VOLUME_UP); +pub const AKEYCODE_VOLUME_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_VOLUME_DOWN); +pub const AKEYCODE_POWER = @intFromEnum(enum_unnamed_16.AKEYCODE_POWER); +pub const AKEYCODE_CAMERA = @intFromEnum(enum_unnamed_16.AKEYCODE_CAMERA); +pub const AKEYCODE_CLEAR = @intFromEnum(enum_unnamed_16.AKEYCODE_CLEAR); +pub const AKEYCODE_A = @intFromEnum(enum_unnamed_16.AKEYCODE_A); +pub const AKEYCODE_B = @intFromEnum(enum_unnamed_16.AKEYCODE_B); +pub const AKEYCODE_C = @intFromEnum(enum_unnamed_16.AKEYCODE_C); +pub const AKEYCODE_D = @intFromEnum(enum_unnamed_16.AKEYCODE_D); +pub const AKEYCODE_E = @intFromEnum(enum_unnamed_16.AKEYCODE_E); +pub const AKEYCODE_F = @intFromEnum(enum_unnamed_16.AKEYCODE_F); +pub const AKEYCODE_G = @intFromEnum(enum_unnamed_16.AKEYCODE_G); +pub const AKEYCODE_H = @intFromEnum(enum_unnamed_16.AKEYCODE_H); +pub const AKEYCODE_I = @intFromEnum(enum_unnamed_16.AKEYCODE_I); +pub const AKEYCODE_J = @intFromEnum(enum_unnamed_16.AKEYCODE_J); +pub const AKEYCODE_K = @intFromEnum(enum_unnamed_16.AKEYCODE_K); +pub const AKEYCODE_L = @intFromEnum(enum_unnamed_16.AKEYCODE_L); +pub const AKEYCODE_M = @intFromEnum(enum_unnamed_16.AKEYCODE_M); +pub const AKEYCODE_N = @intFromEnum(enum_unnamed_16.AKEYCODE_N); +pub const AKEYCODE_O = @intFromEnum(enum_unnamed_16.AKEYCODE_O); +pub const AKEYCODE_P = @intFromEnum(enum_unnamed_16.AKEYCODE_P); +pub const AKEYCODE_Q = @intFromEnum(enum_unnamed_16.AKEYCODE_Q); +pub const AKEYCODE_R = @intFromEnum(enum_unnamed_16.AKEYCODE_R); +pub const AKEYCODE_S = @intFromEnum(enum_unnamed_16.AKEYCODE_S); +pub const AKEYCODE_T = @intFromEnum(enum_unnamed_16.AKEYCODE_T); +pub const AKEYCODE_U = @intFromEnum(enum_unnamed_16.AKEYCODE_U); +pub const AKEYCODE_V = @intFromEnum(enum_unnamed_16.AKEYCODE_V); +pub const AKEYCODE_W = @intFromEnum(enum_unnamed_16.AKEYCODE_W); +pub const AKEYCODE_X = @intFromEnum(enum_unnamed_16.AKEYCODE_X); +pub const AKEYCODE_Y = @intFromEnum(enum_unnamed_16.AKEYCODE_Y); +pub const AKEYCODE_Z = @intFromEnum(enum_unnamed_16.AKEYCODE_Z); +pub const AKEYCODE_COMMA = @intFromEnum(enum_unnamed_16.AKEYCODE_COMMA); +pub const AKEYCODE_PERIOD = @intFromEnum(enum_unnamed_16.AKEYCODE_PERIOD); +pub const AKEYCODE_ALT_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_ALT_LEFT); +pub const AKEYCODE_ALT_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_ALT_RIGHT); +pub const AKEYCODE_SHIFT_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_SHIFT_LEFT); +pub const AKEYCODE_SHIFT_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_SHIFT_RIGHT); +pub const AKEYCODE_TAB = @intFromEnum(enum_unnamed_16.AKEYCODE_TAB); +pub const AKEYCODE_SPACE = @intFromEnum(enum_unnamed_16.AKEYCODE_SPACE); +pub const AKEYCODE_SYM = @intFromEnum(enum_unnamed_16.AKEYCODE_SYM); +pub const AKEYCODE_EXPLORER = @intFromEnum(enum_unnamed_16.AKEYCODE_EXPLORER); +pub const AKEYCODE_ENVELOPE = @intFromEnum(enum_unnamed_16.AKEYCODE_ENVELOPE); +pub const AKEYCODE_ENTER = @intFromEnum(enum_unnamed_16.AKEYCODE_ENTER); +pub const AKEYCODE_DEL = @intFromEnum(enum_unnamed_16.AKEYCODE_DEL); +pub const AKEYCODE_GRAVE = @intFromEnum(enum_unnamed_16.AKEYCODE_GRAVE); +pub const AKEYCODE_MINUS = @intFromEnum(enum_unnamed_16.AKEYCODE_MINUS); +pub const AKEYCODE_EQUALS = @intFromEnum(enum_unnamed_16.AKEYCODE_EQUALS); +pub const AKEYCODE_LEFT_BRACKET = @intFromEnum(enum_unnamed_16.AKEYCODE_LEFT_BRACKET); +pub const AKEYCODE_RIGHT_BRACKET = @intFromEnum(enum_unnamed_16.AKEYCODE_RIGHT_BRACKET); +pub const AKEYCODE_BACKSLASH = @intFromEnum(enum_unnamed_16.AKEYCODE_BACKSLASH); +pub const AKEYCODE_SEMICOLON = @intFromEnum(enum_unnamed_16.AKEYCODE_SEMICOLON); +pub const AKEYCODE_APOSTROPHE = @intFromEnum(enum_unnamed_16.AKEYCODE_APOSTROPHE); +pub const AKEYCODE_SLASH = @intFromEnum(enum_unnamed_16.AKEYCODE_SLASH); +pub const AKEYCODE_AT = @intFromEnum(enum_unnamed_16.AKEYCODE_AT); +pub const AKEYCODE_NUM = @intFromEnum(enum_unnamed_16.AKEYCODE_NUM); +pub const AKEYCODE_HEADSETHOOK = @intFromEnum(enum_unnamed_16.AKEYCODE_HEADSETHOOK); +pub const AKEYCODE_FOCUS = @intFromEnum(enum_unnamed_16.AKEYCODE_FOCUS); +pub const AKEYCODE_PLUS = @intFromEnum(enum_unnamed_16.AKEYCODE_PLUS); +pub const AKEYCODE_MENU = @intFromEnum(enum_unnamed_16.AKEYCODE_MENU); +pub const AKEYCODE_NOTIFICATION = @intFromEnum(enum_unnamed_16.AKEYCODE_NOTIFICATION); +pub const AKEYCODE_SEARCH = @intFromEnum(enum_unnamed_16.AKEYCODE_SEARCH); +pub const AKEYCODE_MEDIA_PLAY_PAUSE = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_PLAY_PAUSE); +pub const AKEYCODE_MEDIA_STOP = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_STOP); +pub const AKEYCODE_MEDIA_NEXT = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_NEXT); +pub const AKEYCODE_MEDIA_PREVIOUS = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_PREVIOUS); +pub const AKEYCODE_MEDIA_REWIND = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_REWIND); +pub const AKEYCODE_MEDIA_FAST_FORWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_FAST_FORWARD); +pub const AKEYCODE_MUTE = @intFromEnum(enum_unnamed_16.AKEYCODE_MUTE); +pub const AKEYCODE_PAGE_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_PAGE_UP); +pub const AKEYCODE_PAGE_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_PAGE_DOWN); +pub const AKEYCODE_PICTSYMBOLS = @intFromEnum(enum_unnamed_16.AKEYCODE_PICTSYMBOLS); +pub const AKEYCODE_SWITCH_CHARSET = @intFromEnum(enum_unnamed_16.AKEYCODE_SWITCH_CHARSET); +pub const AKEYCODE_BUTTON_A = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_A); +pub const AKEYCODE_BUTTON_B = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_B); +pub const AKEYCODE_BUTTON_C = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_C); +pub const AKEYCODE_BUTTON_X = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_X); +pub const AKEYCODE_BUTTON_Y = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_Y); +pub const AKEYCODE_BUTTON_Z = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_Z); +pub const AKEYCODE_BUTTON_L1 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_L1); +pub const AKEYCODE_BUTTON_R1 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_R1); +pub const AKEYCODE_BUTTON_L2 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_L2); +pub const AKEYCODE_BUTTON_R2 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_R2); +pub const AKEYCODE_BUTTON_THUMBL = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_THUMBL); +pub const AKEYCODE_BUTTON_THUMBR = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_THUMBR); +pub const AKEYCODE_BUTTON_START = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_START); +pub const AKEYCODE_BUTTON_SELECT = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_SELECT); +pub const AKEYCODE_BUTTON_MODE = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_MODE); +pub const AKEYCODE_ESCAPE = @intFromEnum(enum_unnamed_16.AKEYCODE_ESCAPE); +pub const AKEYCODE_FORWARD_DEL = @intFromEnum(enum_unnamed_16.AKEYCODE_FORWARD_DEL); +pub const AKEYCODE_CTRL_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_CTRL_LEFT); +pub const AKEYCODE_CTRL_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_CTRL_RIGHT); +pub const AKEYCODE_CAPS_LOCK = @intFromEnum(enum_unnamed_16.AKEYCODE_CAPS_LOCK); +pub const AKEYCODE_SCROLL_LOCK = @intFromEnum(enum_unnamed_16.AKEYCODE_SCROLL_LOCK); +pub const AKEYCODE_META_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_META_LEFT); +pub const AKEYCODE_META_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_META_RIGHT); +pub const AKEYCODE_FUNCTION = @intFromEnum(enum_unnamed_16.AKEYCODE_FUNCTION); +pub const AKEYCODE_SYSRQ = @intFromEnum(enum_unnamed_16.AKEYCODE_SYSRQ); +pub const AKEYCODE_BREAK = @intFromEnum(enum_unnamed_16.AKEYCODE_BREAK); +pub const AKEYCODE_MOVE_HOME = @intFromEnum(enum_unnamed_16.AKEYCODE_MOVE_HOME); +pub const AKEYCODE_MOVE_END = @intFromEnum(enum_unnamed_16.AKEYCODE_MOVE_END); +pub const AKEYCODE_INSERT = @intFromEnum(enum_unnamed_16.AKEYCODE_INSERT); +pub const AKEYCODE_FORWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_FORWARD); +pub const AKEYCODE_MEDIA_PLAY = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_PLAY); +pub const AKEYCODE_MEDIA_PAUSE = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_PAUSE); +pub const AKEYCODE_MEDIA_CLOSE = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_CLOSE); +pub const AKEYCODE_MEDIA_EJECT = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_EJECT); +pub const AKEYCODE_MEDIA_RECORD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_RECORD); +pub const AKEYCODE_F1 = @intFromEnum(enum_unnamed_16.AKEYCODE_F1); +pub const AKEYCODE_F2 = @intFromEnum(enum_unnamed_16.AKEYCODE_F2); +pub const AKEYCODE_F3 = @intFromEnum(enum_unnamed_16.AKEYCODE_F3); +pub const AKEYCODE_F4 = @intFromEnum(enum_unnamed_16.AKEYCODE_F4); +pub const AKEYCODE_F5 = @intFromEnum(enum_unnamed_16.AKEYCODE_F5); +pub const AKEYCODE_F6 = @intFromEnum(enum_unnamed_16.AKEYCODE_F6); +pub const AKEYCODE_F7 = @intFromEnum(enum_unnamed_16.AKEYCODE_F7); +pub const AKEYCODE_F8 = @intFromEnum(enum_unnamed_16.AKEYCODE_F8); +pub const AKEYCODE_F9 = @intFromEnum(enum_unnamed_16.AKEYCODE_F9); +pub const AKEYCODE_F10 = @intFromEnum(enum_unnamed_16.AKEYCODE_F10); +pub const AKEYCODE_F11 = @intFromEnum(enum_unnamed_16.AKEYCODE_F11); +pub const AKEYCODE_F12 = @intFromEnum(enum_unnamed_16.AKEYCODE_F12); +pub const AKEYCODE_NUM_LOCK = @intFromEnum(enum_unnamed_16.AKEYCODE_NUM_LOCK); +pub const AKEYCODE_NUMPAD_0 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_0); +pub const AKEYCODE_NUMPAD_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_1); +pub const AKEYCODE_NUMPAD_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_2); +pub const AKEYCODE_NUMPAD_3 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_3); +pub const AKEYCODE_NUMPAD_4 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_4); +pub const AKEYCODE_NUMPAD_5 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_5); +pub const AKEYCODE_NUMPAD_6 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_6); +pub const AKEYCODE_NUMPAD_7 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_7); +pub const AKEYCODE_NUMPAD_8 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_8); +pub const AKEYCODE_NUMPAD_9 = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_9); +pub const AKEYCODE_NUMPAD_DIVIDE = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_DIVIDE); +pub const AKEYCODE_NUMPAD_MULTIPLY = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_MULTIPLY); +pub const AKEYCODE_NUMPAD_SUBTRACT = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_SUBTRACT); +pub const AKEYCODE_NUMPAD_ADD = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_ADD); +pub const AKEYCODE_NUMPAD_DOT = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_DOT); +pub const AKEYCODE_NUMPAD_COMMA = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_COMMA); +pub const AKEYCODE_NUMPAD_ENTER = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_ENTER); +pub const AKEYCODE_NUMPAD_EQUALS = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_EQUALS); +pub const AKEYCODE_NUMPAD_LEFT_PAREN = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_LEFT_PAREN); +pub const AKEYCODE_NUMPAD_RIGHT_PAREN = @intFromEnum(enum_unnamed_16.AKEYCODE_NUMPAD_RIGHT_PAREN); +pub const AKEYCODE_VOLUME_MUTE = @intFromEnum(enum_unnamed_16.AKEYCODE_VOLUME_MUTE); +pub const AKEYCODE_INFO = @intFromEnum(enum_unnamed_16.AKEYCODE_INFO); +pub const AKEYCODE_CHANNEL_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_CHANNEL_UP); +pub const AKEYCODE_CHANNEL_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_CHANNEL_DOWN); +pub const AKEYCODE_ZOOM_IN = @intFromEnum(enum_unnamed_16.AKEYCODE_ZOOM_IN); +pub const AKEYCODE_ZOOM_OUT = @intFromEnum(enum_unnamed_16.AKEYCODE_ZOOM_OUT); +pub const AKEYCODE_TV = @intFromEnum(enum_unnamed_16.AKEYCODE_TV); +pub const AKEYCODE_WINDOW = @intFromEnum(enum_unnamed_16.AKEYCODE_WINDOW); +pub const AKEYCODE_GUIDE = @intFromEnum(enum_unnamed_16.AKEYCODE_GUIDE); +pub const AKEYCODE_DVR = @intFromEnum(enum_unnamed_16.AKEYCODE_DVR); +pub const AKEYCODE_BOOKMARK = @intFromEnum(enum_unnamed_16.AKEYCODE_BOOKMARK); +pub const AKEYCODE_CAPTIONS = @intFromEnum(enum_unnamed_16.AKEYCODE_CAPTIONS); +pub const AKEYCODE_SETTINGS = @intFromEnum(enum_unnamed_16.AKEYCODE_SETTINGS); +pub const AKEYCODE_TV_POWER = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_POWER); +pub const AKEYCODE_TV_INPUT = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT); +pub const AKEYCODE_STB_POWER = @intFromEnum(enum_unnamed_16.AKEYCODE_STB_POWER); +pub const AKEYCODE_STB_INPUT = @intFromEnum(enum_unnamed_16.AKEYCODE_STB_INPUT); +pub const AKEYCODE_AVR_POWER = @intFromEnum(enum_unnamed_16.AKEYCODE_AVR_POWER); +pub const AKEYCODE_AVR_INPUT = @intFromEnum(enum_unnamed_16.AKEYCODE_AVR_INPUT); +pub const AKEYCODE_PROG_RED = @intFromEnum(enum_unnamed_16.AKEYCODE_PROG_RED); +pub const AKEYCODE_PROG_GREEN = @intFromEnum(enum_unnamed_16.AKEYCODE_PROG_GREEN); +pub const AKEYCODE_PROG_YELLOW = @intFromEnum(enum_unnamed_16.AKEYCODE_PROG_YELLOW); +pub const AKEYCODE_PROG_BLUE = @intFromEnum(enum_unnamed_16.AKEYCODE_PROG_BLUE); +pub const AKEYCODE_APP_SWITCH = @intFromEnum(enum_unnamed_16.AKEYCODE_APP_SWITCH); +pub const AKEYCODE_BUTTON_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_1); +pub const AKEYCODE_BUTTON_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_2); +pub const AKEYCODE_BUTTON_3 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_3); +pub const AKEYCODE_BUTTON_4 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_4); +pub const AKEYCODE_BUTTON_5 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_5); +pub const AKEYCODE_BUTTON_6 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_6); +pub const AKEYCODE_BUTTON_7 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_7); +pub const AKEYCODE_BUTTON_8 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_8); +pub const AKEYCODE_BUTTON_9 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_9); +pub const AKEYCODE_BUTTON_10 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_10); +pub const AKEYCODE_BUTTON_11 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_11); +pub const AKEYCODE_BUTTON_12 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_12); +pub const AKEYCODE_BUTTON_13 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_13); +pub const AKEYCODE_BUTTON_14 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_14); +pub const AKEYCODE_BUTTON_15 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_15); +pub const AKEYCODE_BUTTON_16 = @intFromEnum(enum_unnamed_16.AKEYCODE_BUTTON_16); +pub const AKEYCODE_LANGUAGE_SWITCH = @intFromEnum(enum_unnamed_16.AKEYCODE_LANGUAGE_SWITCH); +pub const AKEYCODE_MANNER_MODE = @intFromEnum(enum_unnamed_16.AKEYCODE_MANNER_MODE); +pub const AKEYCODE_3D_MODE = @intFromEnum(enum_unnamed_16.AKEYCODE_3D_MODE); +pub const AKEYCODE_CONTACTS = @intFromEnum(enum_unnamed_16.AKEYCODE_CONTACTS); +pub const AKEYCODE_CALENDAR = @intFromEnum(enum_unnamed_16.AKEYCODE_CALENDAR); +pub const AKEYCODE_MUSIC = @intFromEnum(enum_unnamed_16.AKEYCODE_MUSIC); +pub const AKEYCODE_CALCULATOR = @intFromEnum(enum_unnamed_16.AKEYCODE_CALCULATOR); +pub const AKEYCODE_ZENKAKU_HANKAKU = @intFromEnum(enum_unnamed_16.AKEYCODE_ZENKAKU_HANKAKU); +pub const AKEYCODE_EISU = @intFromEnum(enum_unnamed_16.AKEYCODE_EISU); +pub const AKEYCODE_MUHENKAN = @intFromEnum(enum_unnamed_16.AKEYCODE_MUHENKAN); +pub const AKEYCODE_HENKAN = @intFromEnum(enum_unnamed_16.AKEYCODE_HENKAN); +pub const AKEYCODE_KATAKANA_HIRAGANA = @intFromEnum(enum_unnamed_16.AKEYCODE_KATAKANA_HIRAGANA); +pub const AKEYCODE_YEN = @intFromEnum(enum_unnamed_16.AKEYCODE_YEN); +pub const AKEYCODE_RO = @intFromEnum(enum_unnamed_16.AKEYCODE_RO); +pub const AKEYCODE_KANA = @intFromEnum(enum_unnamed_16.AKEYCODE_KANA); +pub const AKEYCODE_ASSIST = @intFromEnum(enum_unnamed_16.AKEYCODE_ASSIST); +pub const AKEYCODE_BRIGHTNESS_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_BRIGHTNESS_DOWN); +pub const AKEYCODE_BRIGHTNESS_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_BRIGHTNESS_UP); +pub const AKEYCODE_MEDIA_AUDIO_TRACK = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_AUDIO_TRACK); +pub const AKEYCODE_SLEEP = @intFromEnum(enum_unnamed_16.AKEYCODE_SLEEP); +pub const AKEYCODE_WAKEUP = @intFromEnum(enum_unnamed_16.AKEYCODE_WAKEUP); +pub const AKEYCODE_PAIRING = @intFromEnum(enum_unnamed_16.AKEYCODE_PAIRING); +pub const AKEYCODE_MEDIA_TOP_MENU = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_TOP_MENU); +pub const AKEYCODE_11 = @intFromEnum(enum_unnamed_16.AKEYCODE_11); +pub const AKEYCODE_12 = @intFromEnum(enum_unnamed_16.AKEYCODE_12); +pub const AKEYCODE_LAST_CHANNEL = @intFromEnum(enum_unnamed_16.AKEYCODE_LAST_CHANNEL); +pub const AKEYCODE_TV_DATA_SERVICE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_DATA_SERVICE); +pub const AKEYCODE_VOICE_ASSIST = @intFromEnum(enum_unnamed_16.AKEYCODE_VOICE_ASSIST); +pub const AKEYCODE_TV_RADIO_SERVICE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_RADIO_SERVICE); +pub const AKEYCODE_TV_TELETEXT = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_TELETEXT); +pub const AKEYCODE_TV_NUMBER_ENTRY = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_NUMBER_ENTRY); +pub const AKEYCODE_TV_TERRESTRIAL_ANALOG = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_TERRESTRIAL_ANALOG); +pub const AKEYCODE_TV_TERRESTRIAL_DIGITAL = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_TERRESTRIAL_DIGITAL); +pub const AKEYCODE_TV_SATELLITE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_SATELLITE); +pub const AKEYCODE_TV_SATELLITE_BS = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_SATELLITE_BS); +pub const AKEYCODE_TV_SATELLITE_CS = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_SATELLITE_CS); +pub const AKEYCODE_TV_SATELLITE_SERVICE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_SATELLITE_SERVICE); +pub const AKEYCODE_TV_NETWORK = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_NETWORK); +pub const AKEYCODE_TV_ANTENNA_CABLE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_ANTENNA_CABLE); +pub const AKEYCODE_TV_INPUT_HDMI_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_1); +pub const AKEYCODE_TV_INPUT_HDMI_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_2); +pub const AKEYCODE_TV_INPUT_HDMI_3 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_3); +pub const AKEYCODE_TV_INPUT_HDMI_4 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_HDMI_4); +pub const AKEYCODE_TV_INPUT_COMPOSITE_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPOSITE_1); +pub const AKEYCODE_TV_INPUT_COMPOSITE_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPOSITE_2); +pub const AKEYCODE_TV_INPUT_COMPONENT_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPONENT_1); +pub const AKEYCODE_TV_INPUT_COMPONENT_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_COMPONENT_2); +pub const AKEYCODE_TV_INPUT_VGA_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_INPUT_VGA_1); +pub const AKEYCODE_TV_AUDIO_DESCRIPTION = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION); +pub const AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_UP); +pub const AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_AUDIO_DESCRIPTION_MIX_DOWN); +pub const AKEYCODE_TV_ZOOM_MODE = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_ZOOM_MODE); +pub const AKEYCODE_TV_CONTENTS_MENU = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_CONTENTS_MENU); +pub const AKEYCODE_TV_MEDIA_CONTEXT_MENU = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_MEDIA_CONTEXT_MENU); +pub const AKEYCODE_TV_TIMER_PROGRAMMING = @intFromEnum(enum_unnamed_16.AKEYCODE_TV_TIMER_PROGRAMMING); +pub const AKEYCODE_HELP = @intFromEnum(enum_unnamed_16.AKEYCODE_HELP); +pub const AKEYCODE_NAVIGATE_PREVIOUS = @intFromEnum(enum_unnamed_16.AKEYCODE_NAVIGATE_PREVIOUS); +pub const AKEYCODE_NAVIGATE_NEXT = @intFromEnum(enum_unnamed_16.AKEYCODE_NAVIGATE_NEXT); +pub const AKEYCODE_NAVIGATE_IN = @intFromEnum(enum_unnamed_16.AKEYCODE_NAVIGATE_IN); +pub const AKEYCODE_NAVIGATE_OUT = @intFromEnum(enum_unnamed_16.AKEYCODE_NAVIGATE_OUT); +pub const AKEYCODE_STEM_PRIMARY = @intFromEnum(enum_unnamed_16.AKEYCODE_STEM_PRIMARY); +pub const AKEYCODE_STEM_1 = @intFromEnum(enum_unnamed_16.AKEYCODE_STEM_1); +pub const AKEYCODE_STEM_2 = @intFromEnum(enum_unnamed_16.AKEYCODE_STEM_2); +pub const AKEYCODE_STEM_3 = @intFromEnum(enum_unnamed_16.AKEYCODE_STEM_3); +pub const AKEYCODE_DPAD_UP_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_UP_LEFT); +pub const AKEYCODE_DPAD_DOWN_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_DOWN_LEFT); +pub const AKEYCODE_DPAD_UP_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_UP_RIGHT); +pub const AKEYCODE_DPAD_DOWN_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_DPAD_DOWN_RIGHT); +pub const AKEYCODE_MEDIA_SKIP_FORWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_SKIP_FORWARD); +pub const AKEYCODE_MEDIA_SKIP_BACKWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_SKIP_BACKWARD); +pub const AKEYCODE_MEDIA_STEP_FORWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_STEP_FORWARD); +pub const AKEYCODE_MEDIA_STEP_BACKWARD = @intFromEnum(enum_unnamed_16.AKEYCODE_MEDIA_STEP_BACKWARD); +pub const AKEYCODE_SOFT_SLEEP = @intFromEnum(enum_unnamed_16.AKEYCODE_SOFT_SLEEP); +pub const AKEYCODE_CUT = @intFromEnum(enum_unnamed_16.AKEYCODE_CUT); +pub const AKEYCODE_COPY = @intFromEnum(enum_unnamed_16.AKEYCODE_COPY); +pub const AKEYCODE_PASTE = @intFromEnum(enum_unnamed_16.AKEYCODE_PASTE); +pub const AKEYCODE_SYSTEM_NAVIGATION_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_UP); +pub const AKEYCODE_SYSTEM_NAVIGATION_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_DOWN); +pub const AKEYCODE_SYSTEM_NAVIGATION_LEFT = @intFromEnum(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_LEFT); +pub const AKEYCODE_SYSTEM_NAVIGATION_RIGHT = @intFromEnum(enum_unnamed_16.AKEYCODE_SYSTEM_NAVIGATION_RIGHT); +pub const AKEYCODE_ALL_APPS = @intFromEnum(enum_unnamed_16.AKEYCODE_ALL_APPS); +pub const AKEYCODE_REFRESH = @intFromEnum(enum_unnamed_16.AKEYCODE_REFRESH); +pub const AKEYCODE_THUMBS_UP = @intFromEnum(enum_unnamed_16.AKEYCODE_THUMBS_UP); +pub const AKEYCODE_THUMBS_DOWN = @intFromEnum(enum_unnamed_16.AKEYCODE_THUMBS_DOWN); +pub const AKEYCODE_PROFILE_SWITCH = @intFromEnum(enum_unnamed_16.AKEYCODE_PROFILE_SWITCH); const enum_unnamed_16 = enum(c_int) { AKEYCODE_UNKNOWN = 0, AKEYCODE_SOFT_LEFT = 1, @@ -1363,10 +1363,10 @@ const enum_unnamed_16 = enum(c_int) { AKEYCODE_PROFILE_SWITCH = 288, _, }; -pub const AKEY_STATE_UNKNOWN = @enumToInt(enum_unnamed_17.AKEY_STATE_UNKNOWN); -pub const AKEY_STATE_UP = @enumToInt(enum_unnamed_17.AKEY_STATE_UP); -pub const AKEY_STATE_DOWN = @enumToInt(enum_unnamed_17.AKEY_STATE_DOWN); -pub const AKEY_STATE_VIRTUAL = @enumToInt(enum_unnamed_17.AKEY_STATE_VIRTUAL); +pub const AKEY_STATE_UNKNOWN = @intFromEnum(enum_unnamed_17.AKEY_STATE_UNKNOWN); +pub const AKEY_STATE_UP = @intFromEnum(enum_unnamed_17.AKEY_STATE_UP); +pub const AKEY_STATE_DOWN = @intFromEnum(enum_unnamed_17.AKEY_STATE_DOWN); +pub const AKEY_STATE_VIRTUAL = @intFromEnum(enum_unnamed_17.AKEY_STATE_VIRTUAL); const enum_unnamed_17 = enum(c_int) { AKEY_STATE_UNKNOWN = -1, AKEY_STATE_UP = 0, @@ -1374,24 +1374,24 @@ const enum_unnamed_17 = enum(c_int) { AKEY_STATE_VIRTUAL = 2, _, }; -pub const AMETA_NONE = @enumToInt(enum_unnamed_18.AMETA_NONE); -pub const AMETA_ALT_ON = @enumToInt(enum_unnamed_18.AMETA_ALT_ON); -pub const AMETA_ALT_LEFT_ON = @enumToInt(enum_unnamed_18.AMETA_ALT_LEFT_ON); -pub const AMETA_ALT_RIGHT_ON = @enumToInt(enum_unnamed_18.AMETA_ALT_RIGHT_ON); -pub const AMETA_SHIFT_ON = @enumToInt(enum_unnamed_18.AMETA_SHIFT_ON); -pub const AMETA_SHIFT_LEFT_ON = @enumToInt(enum_unnamed_18.AMETA_SHIFT_LEFT_ON); -pub const AMETA_SHIFT_RIGHT_ON = @enumToInt(enum_unnamed_18.AMETA_SHIFT_RIGHT_ON); -pub const AMETA_SYM_ON = @enumToInt(enum_unnamed_18.AMETA_SYM_ON); -pub const AMETA_FUNCTION_ON = @enumToInt(enum_unnamed_18.AMETA_FUNCTION_ON); -pub const AMETA_CTRL_ON = @enumToInt(enum_unnamed_18.AMETA_CTRL_ON); -pub const AMETA_CTRL_LEFT_ON = @enumToInt(enum_unnamed_18.AMETA_CTRL_LEFT_ON); -pub const AMETA_CTRL_RIGHT_ON = @enumToInt(enum_unnamed_18.AMETA_CTRL_RIGHT_ON); -pub const AMETA_META_ON = @enumToInt(enum_unnamed_18.AMETA_META_ON); -pub const AMETA_META_LEFT_ON = @enumToInt(enum_unnamed_18.AMETA_META_LEFT_ON); -pub const AMETA_META_RIGHT_ON = @enumToInt(enum_unnamed_18.AMETA_META_RIGHT_ON); -pub const AMETA_CAPS_LOCK_ON = @enumToInt(enum_unnamed_18.AMETA_CAPS_LOCK_ON); -pub const AMETA_NUM_LOCK_ON = @enumToInt(enum_unnamed_18.AMETA_NUM_LOCK_ON); -pub const AMETA_SCROLL_LOCK_ON = @enumToInt(enum_unnamed_18.AMETA_SCROLL_LOCK_ON); +pub const AMETA_NONE = @intFromEnum(enum_unnamed_18.AMETA_NONE); +pub const AMETA_ALT_ON = @intFromEnum(enum_unnamed_18.AMETA_ALT_ON); +pub const AMETA_ALT_LEFT_ON = @intFromEnum(enum_unnamed_18.AMETA_ALT_LEFT_ON); +pub const AMETA_ALT_RIGHT_ON = @intFromEnum(enum_unnamed_18.AMETA_ALT_RIGHT_ON); +pub const AMETA_SHIFT_ON = @intFromEnum(enum_unnamed_18.AMETA_SHIFT_ON); +pub const AMETA_SHIFT_LEFT_ON = @intFromEnum(enum_unnamed_18.AMETA_SHIFT_LEFT_ON); +pub const AMETA_SHIFT_RIGHT_ON = @intFromEnum(enum_unnamed_18.AMETA_SHIFT_RIGHT_ON); +pub const AMETA_SYM_ON = @intFromEnum(enum_unnamed_18.AMETA_SYM_ON); +pub const AMETA_FUNCTION_ON = @intFromEnum(enum_unnamed_18.AMETA_FUNCTION_ON); +pub const AMETA_CTRL_ON = @intFromEnum(enum_unnamed_18.AMETA_CTRL_ON); +pub const AMETA_CTRL_LEFT_ON = @intFromEnum(enum_unnamed_18.AMETA_CTRL_LEFT_ON); +pub const AMETA_CTRL_RIGHT_ON = @intFromEnum(enum_unnamed_18.AMETA_CTRL_RIGHT_ON); +pub const AMETA_META_ON = @intFromEnum(enum_unnamed_18.AMETA_META_ON); +pub const AMETA_META_LEFT_ON = @intFromEnum(enum_unnamed_18.AMETA_META_LEFT_ON); +pub const AMETA_META_RIGHT_ON = @intFromEnum(enum_unnamed_18.AMETA_META_RIGHT_ON); +pub const AMETA_CAPS_LOCK_ON = @intFromEnum(enum_unnamed_18.AMETA_CAPS_LOCK_ON); +pub const AMETA_NUM_LOCK_ON = @intFromEnum(enum_unnamed_18.AMETA_NUM_LOCK_ON); +pub const AMETA_SCROLL_LOCK_ON = @intFromEnum(enum_unnamed_18.AMETA_SCROLL_LOCK_ON); const enum_unnamed_18 = enum(c_int) { AMETA_NONE = 0, AMETA_ALT_ON = 2, @@ -1419,26 +1419,26 @@ pub const AInputEventType = enum(c_int) { AINPUT_EVENT_TYPE_MOTION = 2, _, }; -pub const AKEY_EVENT_ACTION_DOWN = @enumToInt(AKeyEventActionType.AKEY_EVENT_ACTION_DOWN); -pub const AKEY_EVENT_ACTION_UP = @enumToInt(AKeyEventActionType.AKEY_EVENT_ACTION_UP); -pub const AKEY_EVENT_ACTION_MULTIPLE = @enumToInt(AKeyEventActionType.AKEY_EVENT_ACTION_MULTIPLE); +pub const AKEY_EVENT_ACTION_DOWN = @intFromEnum(AKeyEventActionType.AKEY_EVENT_ACTION_DOWN); +pub const AKEY_EVENT_ACTION_UP = @intFromEnum(AKeyEventActionType.AKEY_EVENT_ACTION_UP); +pub const AKEY_EVENT_ACTION_MULTIPLE = @intFromEnum(AKeyEventActionType.AKEY_EVENT_ACTION_MULTIPLE); pub const AKeyEventActionType = enum(c_int) { AKEY_EVENT_ACTION_DOWN = 0, AKEY_EVENT_ACTION_UP = 1, AKEY_EVENT_ACTION_MULTIPLE = 2, _, }; -pub const AKEY_EVENT_FLAG_WOKE_HERE = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_WOKE_HERE); -pub const AKEY_EVENT_FLAG_SOFT_KEYBOARD = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_SOFT_KEYBOARD); -pub const AKEY_EVENT_FLAG_KEEP_TOUCH_MODE = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_KEEP_TOUCH_MODE); -pub const AKEY_EVENT_FLAG_FROM_SYSTEM = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_FROM_SYSTEM); -pub const AKEY_EVENT_FLAG_EDITOR_ACTION = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_EDITOR_ACTION); -pub const AKEY_EVENT_FLAG_CANCELED = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_CANCELED); -pub const AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); -pub const AKEY_EVENT_FLAG_LONG_PRESS = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_LONG_PRESS); -pub const AKEY_EVENT_FLAG_CANCELED_LONG_PRESS = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_CANCELED_LONG_PRESS); -pub const AKEY_EVENT_FLAG_TRACKING = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_TRACKING); -pub const AKEY_EVENT_FLAG_FALLBACK = @enumToInt(enum_unnamed_21.AKEY_EVENT_FLAG_FALLBACK); +pub const AKEY_EVENT_FLAG_WOKE_HERE = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_WOKE_HERE); +pub const AKEY_EVENT_FLAG_SOFT_KEYBOARD = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_SOFT_KEYBOARD); +pub const AKEY_EVENT_FLAG_KEEP_TOUCH_MODE = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_KEEP_TOUCH_MODE); +pub const AKEY_EVENT_FLAG_FROM_SYSTEM = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_FROM_SYSTEM); +pub const AKEY_EVENT_FLAG_EDITOR_ACTION = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_EDITOR_ACTION); +pub const AKEY_EVENT_FLAG_CANCELED = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_CANCELED); +pub const AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY); +pub const AKEY_EVENT_FLAG_LONG_PRESS = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_LONG_PRESS); +pub const AKEY_EVENT_FLAG_CANCELED_LONG_PRESS = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_CANCELED_LONG_PRESS); +pub const AKEY_EVENT_FLAG_TRACKING = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_TRACKING); +pub const AKEY_EVENT_FLAG_FALLBACK = @intFromEnum(enum_unnamed_21.AKEY_EVENT_FLAG_FALLBACK); const enum_unnamed_21 = enum(c_int) { AKEY_EVENT_FLAG_WOKE_HERE = 1, AKEY_EVENT_FLAG_SOFT_KEYBOARD = 2, @@ -1453,21 +1453,21 @@ const enum_unnamed_21 = enum(c_int) { AKEY_EVENT_FLAG_FALLBACK = 1024, _, }; -pub const AMOTION_EVENT_ACTION_MASK = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_MASK); -pub const AMOTION_EVENT_ACTION_POINTER_INDEX_MASK = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_INDEX_MASK); -pub const AMOTION_EVENT_ACTION_DOWN = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_DOWN); -pub const AMOTION_EVENT_ACTION_UP = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_UP); -pub const AMOTION_EVENT_ACTION_MOVE = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_MOVE); -pub const AMOTION_EVENT_ACTION_CANCEL = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_CANCEL); -pub const AMOTION_EVENT_ACTION_OUTSIDE = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_OUTSIDE); -pub const AMOTION_EVENT_ACTION_POINTER_DOWN = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_DOWN); -pub const AMOTION_EVENT_ACTION_POINTER_UP = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_UP); -pub const AMOTION_EVENT_ACTION_HOVER_MOVE = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_MOVE); -pub const AMOTION_EVENT_ACTION_SCROLL = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_SCROLL); -pub const AMOTION_EVENT_ACTION_HOVER_ENTER = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_ENTER); -pub const AMOTION_EVENT_ACTION_HOVER_EXIT = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_EXIT); -pub const AMOTION_EVENT_ACTION_BUTTON_PRESS = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_BUTTON_PRESS); -pub const AMOTION_EVENT_ACTION_BUTTON_RELEASE = @enumToInt(AMotionEventActionType.AMOTION_EVENT_ACTION_BUTTON_RELEASE); +pub const AMOTION_EVENT_ACTION_MASK = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_MASK); +pub const AMOTION_EVENT_ACTION_POINTER_INDEX_MASK = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_INDEX_MASK); +pub const AMOTION_EVENT_ACTION_DOWN = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_DOWN); +pub const AMOTION_EVENT_ACTION_UP = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_UP); +pub const AMOTION_EVENT_ACTION_MOVE = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_MOVE); +pub const AMOTION_EVENT_ACTION_CANCEL = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_CANCEL); +pub const AMOTION_EVENT_ACTION_OUTSIDE = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_OUTSIDE); +pub const AMOTION_EVENT_ACTION_POINTER_DOWN = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_DOWN); +pub const AMOTION_EVENT_ACTION_POINTER_UP = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_POINTER_UP); +pub const AMOTION_EVENT_ACTION_HOVER_MOVE = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_MOVE); +pub const AMOTION_EVENT_ACTION_SCROLL = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_SCROLL); +pub const AMOTION_EVENT_ACTION_HOVER_ENTER = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_ENTER); +pub const AMOTION_EVENT_ACTION_HOVER_EXIT = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_HOVER_EXIT); +pub const AMOTION_EVENT_ACTION_BUTTON_PRESS = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_BUTTON_PRESS); +pub const AMOTION_EVENT_ACTION_BUTTON_RELEASE = @intFromEnum(AMotionEventActionType.AMOTION_EVENT_ACTION_BUTTON_RELEASE); pub const AMotionEventActionType = enum(c_int) { AMOTION_EVENT_ACTION_MASK = 255, AMOTION_EVENT_ACTION_POINTER_INDEX_MASK = 65280, @@ -1486,16 +1486,16 @@ pub const AMotionEventActionType = enum(c_int) { AMOTION_EVENT_ACTION_BUTTON_RELEASE = 12, _, }; -pub const AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED = @enumToInt(enum_unnamed_23.AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED); +pub const AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED = @intFromEnum(enum_unnamed_23.AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED); const enum_unnamed_23 = enum(c_int) { AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED = 1, _, }; -pub const AMOTION_EVENT_EDGE_FLAG_NONE = @enumToInt(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_NONE); -pub const AMOTION_EVENT_EDGE_FLAG_TOP = @enumToInt(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_TOP); -pub const AMOTION_EVENT_EDGE_FLAG_BOTTOM = @enumToInt(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_BOTTOM); -pub const AMOTION_EVENT_EDGE_FLAG_LEFT = @enumToInt(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_LEFT); -pub const AMOTION_EVENT_EDGE_FLAG_RIGHT = @enumToInt(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_RIGHT); +pub const AMOTION_EVENT_EDGE_FLAG_NONE = @intFromEnum(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_NONE); +pub const AMOTION_EVENT_EDGE_FLAG_TOP = @intFromEnum(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_TOP); +pub const AMOTION_EVENT_EDGE_FLAG_BOTTOM = @intFromEnum(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_BOTTOM); +pub const AMOTION_EVENT_EDGE_FLAG_LEFT = @intFromEnum(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_LEFT); +pub const AMOTION_EVENT_EDGE_FLAG_RIGHT = @intFromEnum(enum_unnamed_24.AMOTION_EVENT_EDGE_FLAG_RIGHT); const enum_unnamed_24 = enum(c_int) { AMOTION_EVENT_EDGE_FLAG_NONE = 0, AMOTION_EVENT_EDGE_FLAG_TOP = 1, @@ -1504,51 +1504,51 @@ const enum_unnamed_24 = enum(c_int) { AMOTION_EVENT_EDGE_FLAG_RIGHT = 8, _, }; -pub const AMOTION_EVENT_AXIS_X = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_X); -pub const AMOTION_EVENT_AXIS_Y = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_Y); -pub const AMOTION_EVENT_AXIS_PRESSURE = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_PRESSURE); -pub const AMOTION_EVENT_AXIS_SIZE = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_SIZE); -pub const AMOTION_EVENT_AXIS_TOUCH_MAJOR = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_TOUCH_MAJOR); -pub const AMOTION_EVENT_AXIS_TOUCH_MINOR = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_TOUCH_MINOR); -pub const AMOTION_EVENT_AXIS_TOOL_MAJOR = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_TOOL_MAJOR); -pub const AMOTION_EVENT_AXIS_TOOL_MINOR = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_TOOL_MINOR); -pub const AMOTION_EVENT_AXIS_ORIENTATION = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_ORIENTATION); -pub const AMOTION_EVENT_AXIS_VSCROLL = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_VSCROLL); -pub const AMOTION_EVENT_AXIS_HSCROLL = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_HSCROLL); -pub const AMOTION_EVENT_AXIS_Z = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_Z); -pub const AMOTION_EVENT_AXIS_RX = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RX); -pub const AMOTION_EVENT_AXIS_RY = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RY); -pub const AMOTION_EVENT_AXIS_RZ = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RZ); -pub const AMOTION_EVENT_AXIS_HAT_X = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_HAT_X); -pub const AMOTION_EVENT_AXIS_HAT_Y = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_HAT_Y); -pub const AMOTION_EVENT_AXIS_LTRIGGER = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_LTRIGGER); -pub const AMOTION_EVENT_AXIS_RTRIGGER = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RTRIGGER); -pub const AMOTION_EVENT_AXIS_THROTTLE = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_THROTTLE); -pub const AMOTION_EVENT_AXIS_RUDDER = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RUDDER); -pub const AMOTION_EVENT_AXIS_WHEEL = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_WHEEL); -pub const AMOTION_EVENT_AXIS_GAS = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GAS); -pub const AMOTION_EVENT_AXIS_BRAKE = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_BRAKE); -pub const AMOTION_EVENT_AXIS_DISTANCE = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_DISTANCE); -pub const AMOTION_EVENT_AXIS_TILT = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_TILT); -pub const AMOTION_EVENT_AXIS_SCROLL = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_SCROLL); -pub const AMOTION_EVENT_AXIS_RELATIVE_X = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RELATIVE_X); -pub const AMOTION_EVENT_AXIS_RELATIVE_Y = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_RELATIVE_Y); -pub const AMOTION_EVENT_AXIS_GENERIC_1 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_1); -pub const AMOTION_EVENT_AXIS_GENERIC_2 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_2); -pub const AMOTION_EVENT_AXIS_GENERIC_3 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_3); -pub const AMOTION_EVENT_AXIS_GENERIC_4 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_4); -pub const AMOTION_EVENT_AXIS_GENERIC_5 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_5); -pub const AMOTION_EVENT_AXIS_GENERIC_6 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_6); -pub const AMOTION_EVENT_AXIS_GENERIC_7 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_7); -pub const AMOTION_EVENT_AXIS_GENERIC_8 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_8); -pub const AMOTION_EVENT_AXIS_GENERIC_9 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_9); -pub const AMOTION_EVENT_AXIS_GENERIC_10 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_10); -pub const AMOTION_EVENT_AXIS_GENERIC_11 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_11); -pub const AMOTION_EVENT_AXIS_GENERIC_12 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_12); -pub const AMOTION_EVENT_AXIS_GENERIC_13 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_13); -pub const AMOTION_EVENT_AXIS_GENERIC_14 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_14); -pub const AMOTION_EVENT_AXIS_GENERIC_15 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_15); -pub const AMOTION_EVENT_AXIS_GENERIC_16 = @enumToInt(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_16); +pub const AMOTION_EVENT_AXIS_X = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_X); +pub const AMOTION_EVENT_AXIS_Y = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_Y); +pub const AMOTION_EVENT_AXIS_PRESSURE = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_PRESSURE); +pub const AMOTION_EVENT_AXIS_SIZE = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_SIZE); +pub const AMOTION_EVENT_AXIS_TOUCH_MAJOR = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_TOUCH_MAJOR); +pub const AMOTION_EVENT_AXIS_TOUCH_MINOR = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_TOUCH_MINOR); +pub const AMOTION_EVENT_AXIS_TOOL_MAJOR = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_TOOL_MAJOR); +pub const AMOTION_EVENT_AXIS_TOOL_MINOR = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_TOOL_MINOR); +pub const AMOTION_EVENT_AXIS_ORIENTATION = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_ORIENTATION); +pub const AMOTION_EVENT_AXIS_VSCROLL = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_VSCROLL); +pub const AMOTION_EVENT_AXIS_HSCROLL = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_HSCROLL); +pub const AMOTION_EVENT_AXIS_Z = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_Z); +pub const AMOTION_EVENT_AXIS_RX = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RX); +pub const AMOTION_EVENT_AXIS_RY = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RY); +pub const AMOTION_EVENT_AXIS_RZ = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RZ); +pub const AMOTION_EVENT_AXIS_HAT_X = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_HAT_X); +pub const AMOTION_EVENT_AXIS_HAT_Y = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_HAT_Y); +pub const AMOTION_EVENT_AXIS_LTRIGGER = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_LTRIGGER); +pub const AMOTION_EVENT_AXIS_RTRIGGER = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RTRIGGER); +pub const AMOTION_EVENT_AXIS_THROTTLE = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_THROTTLE); +pub const AMOTION_EVENT_AXIS_RUDDER = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RUDDER); +pub const AMOTION_EVENT_AXIS_WHEEL = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_WHEEL); +pub const AMOTION_EVENT_AXIS_GAS = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GAS); +pub const AMOTION_EVENT_AXIS_BRAKE = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_BRAKE); +pub const AMOTION_EVENT_AXIS_DISTANCE = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_DISTANCE); +pub const AMOTION_EVENT_AXIS_TILT = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_TILT); +pub const AMOTION_EVENT_AXIS_SCROLL = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_SCROLL); +pub const AMOTION_EVENT_AXIS_RELATIVE_X = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RELATIVE_X); +pub const AMOTION_EVENT_AXIS_RELATIVE_Y = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_RELATIVE_Y); +pub const AMOTION_EVENT_AXIS_GENERIC_1 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_1); +pub const AMOTION_EVENT_AXIS_GENERIC_2 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_2); +pub const AMOTION_EVENT_AXIS_GENERIC_3 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_3); +pub const AMOTION_EVENT_AXIS_GENERIC_4 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_4); +pub const AMOTION_EVENT_AXIS_GENERIC_5 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_5); +pub const AMOTION_EVENT_AXIS_GENERIC_6 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_6); +pub const AMOTION_EVENT_AXIS_GENERIC_7 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_7); +pub const AMOTION_EVENT_AXIS_GENERIC_8 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_8); +pub const AMOTION_EVENT_AXIS_GENERIC_9 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_9); +pub const AMOTION_EVENT_AXIS_GENERIC_10 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_10); +pub const AMOTION_EVENT_AXIS_GENERIC_11 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_11); +pub const AMOTION_EVENT_AXIS_GENERIC_12 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_12); +pub const AMOTION_EVENT_AXIS_GENERIC_13 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_13); +pub const AMOTION_EVENT_AXIS_GENERIC_14 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_14); +pub const AMOTION_EVENT_AXIS_GENERIC_15 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_15); +pub const AMOTION_EVENT_AXIS_GENERIC_16 = @intFromEnum(enum_unnamed_25.AMOTION_EVENT_AXIS_GENERIC_16); const enum_unnamed_25 = enum(c_int) { AMOTION_EVENT_AXIS_X = 0, AMOTION_EVENT_AXIS_Y = 1, @@ -1597,13 +1597,13 @@ const enum_unnamed_25 = enum(c_int) { AMOTION_EVENT_AXIS_GENERIC_16 = 47, _, }; -pub const AMOTION_EVENT_BUTTON_PRIMARY = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_PRIMARY); -pub const AMOTION_EVENT_BUTTON_SECONDARY = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_SECONDARY); -pub const AMOTION_EVENT_BUTTON_TERTIARY = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_TERTIARY); -pub const AMOTION_EVENT_BUTTON_BACK = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_BACK); -pub const AMOTION_EVENT_BUTTON_FORWARD = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_FORWARD); -pub const AMOTION_EVENT_BUTTON_STYLUS_PRIMARY = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_STYLUS_PRIMARY); -pub const AMOTION_EVENT_BUTTON_STYLUS_SECONDARY = @enumToInt(enum_unnamed_26.AMOTION_EVENT_BUTTON_STYLUS_SECONDARY); +pub const AMOTION_EVENT_BUTTON_PRIMARY = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_PRIMARY); +pub const AMOTION_EVENT_BUTTON_SECONDARY = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_SECONDARY); +pub const AMOTION_EVENT_BUTTON_TERTIARY = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_TERTIARY); +pub const AMOTION_EVENT_BUTTON_BACK = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_BACK); +pub const AMOTION_EVENT_BUTTON_FORWARD = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_FORWARD); +pub const AMOTION_EVENT_BUTTON_STYLUS_PRIMARY = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_STYLUS_PRIMARY); +pub const AMOTION_EVENT_BUTTON_STYLUS_SECONDARY = @intFromEnum(enum_unnamed_26.AMOTION_EVENT_BUTTON_STYLUS_SECONDARY); const enum_unnamed_26 = enum(c_int) { AMOTION_EVENT_BUTTON_PRIMARY = 1, AMOTION_EVENT_BUTTON_SECONDARY = 2, @@ -1614,11 +1614,11 @@ const enum_unnamed_26 = enum(c_int) { AMOTION_EVENT_BUTTON_STYLUS_SECONDARY = 64, _, }; -pub const AMOTION_EVENT_TOOL_TYPE_UNKNOWN = @enumToInt(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_UNKNOWN); -pub const AMOTION_EVENT_TOOL_TYPE_FINGER = @enumToInt(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_FINGER); -pub const AMOTION_EVENT_TOOL_TYPE_STYLUS = @enumToInt(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_STYLUS); -pub const AMOTION_EVENT_TOOL_TYPE_MOUSE = @enumToInt(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_MOUSE); -pub const AMOTION_EVENT_TOOL_TYPE_ERASER = @enumToInt(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_ERASER); +pub const AMOTION_EVENT_TOOL_TYPE_UNKNOWN = @intFromEnum(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_UNKNOWN); +pub const AMOTION_EVENT_TOOL_TYPE_FINGER = @intFromEnum(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_FINGER); +pub const AMOTION_EVENT_TOOL_TYPE_STYLUS = @intFromEnum(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_STYLUS); +pub const AMOTION_EVENT_TOOL_TYPE_MOUSE = @intFromEnum(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_MOUSE); +pub const AMOTION_EVENT_TOOL_TYPE_ERASER = @intFromEnum(enum_unnamed_27.AMOTION_EVENT_TOOL_TYPE_ERASER); const enum_unnamed_27 = enum(c_int) { AMOTION_EVENT_TOOL_TYPE_UNKNOWN = 0, AMOTION_EVENT_TOOL_TYPE_FINGER = 1, @@ -1627,13 +1627,13 @@ const enum_unnamed_27 = enum(c_int) { AMOTION_EVENT_TOOL_TYPE_ERASER = 4, _, }; -pub const AINPUT_SOURCE_CLASS_MASK = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_MASK); -pub const AINPUT_SOURCE_CLASS_NONE = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_NONE); -pub const AINPUT_SOURCE_CLASS_BUTTON = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_BUTTON); -pub const AINPUT_SOURCE_CLASS_POINTER = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_POINTER); -pub const AINPUT_SOURCE_CLASS_NAVIGATION = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_NAVIGATION); -pub const AINPUT_SOURCE_CLASS_POSITION = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_POSITION); -pub const AINPUT_SOURCE_CLASS_JOYSTICK = @enumToInt(enum_unnamed_28.AINPUT_SOURCE_CLASS_JOYSTICK); +pub const AINPUT_SOURCE_CLASS_MASK = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_MASK); +pub const AINPUT_SOURCE_CLASS_NONE = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_NONE); +pub const AINPUT_SOURCE_CLASS_BUTTON = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_BUTTON); +pub const AINPUT_SOURCE_CLASS_POINTER = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_POINTER); +pub const AINPUT_SOURCE_CLASS_NAVIGATION = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_NAVIGATION); +pub const AINPUT_SOURCE_CLASS_POSITION = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_POSITION); +pub const AINPUT_SOURCE_CLASS_JOYSTICK = @intFromEnum(enum_unnamed_28.AINPUT_SOURCE_CLASS_JOYSTICK); const enum_unnamed_28 = enum(c_int) { AINPUT_SOURCE_CLASS_MASK = 255, AINPUT_SOURCE_CLASS_NONE = 0, @@ -1644,21 +1644,21 @@ const enum_unnamed_28 = enum(c_int) { AINPUT_SOURCE_CLASS_JOYSTICK = 16, _, }; -pub const AINPUT_SOURCE_UNKNOWN = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_UNKNOWN); -pub const AINPUT_SOURCE_KEYBOARD = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_KEYBOARD); -pub const AINPUT_SOURCE_DPAD = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_DPAD); -pub const AINPUT_SOURCE_GAMEPAD = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_GAMEPAD); -pub const AINPUT_SOURCE_TOUCHSCREEN = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_TOUCHSCREEN); -pub const AINPUT_SOURCE_MOUSE = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_MOUSE); -pub const AINPUT_SOURCE_STYLUS = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_STYLUS); -pub const AINPUT_SOURCE_BLUETOOTH_STYLUS = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_BLUETOOTH_STYLUS); -pub const AINPUT_SOURCE_TRACKBALL = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_TRACKBALL); -pub const AINPUT_SOURCE_MOUSE_RELATIVE = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_MOUSE_RELATIVE); -pub const AINPUT_SOURCE_TOUCHPAD = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_TOUCHPAD); -pub const AINPUT_SOURCE_TOUCH_NAVIGATION = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_TOUCH_NAVIGATION); -pub const AINPUT_SOURCE_JOYSTICK = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_JOYSTICK); -pub const AINPUT_SOURCE_ROTARY_ENCODER = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_ROTARY_ENCODER); -pub const AINPUT_SOURCE_ANY = @enumToInt(enum_unnamed_29.AINPUT_SOURCE_ANY); +pub const AINPUT_SOURCE_UNKNOWN = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_UNKNOWN); +pub const AINPUT_SOURCE_KEYBOARD = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_KEYBOARD); +pub const AINPUT_SOURCE_DPAD = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_DPAD); +pub const AINPUT_SOURCE_GAMEPAD = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_GAMEPAD); +pub const AINPUT_SOURCE_TOUCHSCREEN = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_TOUCHSCREEN); +pub const AINPUT_SOURCE_MOUSE = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_MOUSE); +pub const AINPUT_SOURCE_STYLUS = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_STYLUS); +pub const AINPUT_SOURCE_BLUETOOTH_STYLUS = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_BLUETOOTH_STYLUS); +pub const AINPUT_SOURCE_TRACKBALL = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_TRACKBALL); +pub const AINPUT_SOURCE_MOUSE_RELATIVE = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_MOUSE_RELATIVE); +pub const AINPUT_SOURCE_TOUCHPAD = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_TOUCHPAD); +pub const AINPUT_SOURCE_TOUCH_NAVIGATION = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_TOUCH_NAVIGATION); +pub const AINPUT_SOURCE_JOYSTICK = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_JOYSTICK); +pub const AINPUT_SOURCE_ROTARY_ENCODER = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_ROTARY_ENCODER); +pub const AINPUT_SOURCE_ANY = @intFromEnum(enum_unnamed_29.AINPUT_SOURCE_ANY); const enum_unnamed_29 = enum(c_int) { AINPUT_SOURCE_UNKNOWN = 0, AINPUT_SOURCE_KEYBOARD = 257, @@ -1677,24 +1677,24 @@ const enum_unnamed_29 = enum(c_int) { AINPUT_SOURCE_ANY = 4294967040, _, }; -pub const AINPUT_KEYBOARD_TYPE_NONE = @enumToInt(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_NONE); -pub const AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC = @enumToInt(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); -pub const AINPUT_KEYBOARD_TYPE_ALPHABETIC = @enumToInt(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_ALPHABETIC); +pub const AINPUT_KEYBOARD_TYPE_NONE = @intFromEnum(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_NONE); +pub const AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC = @intFromEnum(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC); +pub const AINPUT_KEYBOARD_TYPE_ALPHABETIC = @intFromEnum(enum_unnamed_30.AINPUT_KEYBOARD_TYPE_ALPHABETIC); const enum_unnamed_30 = enum(c_int) { AINPUT_KEYBOARD_TYPE_NONE = 0, AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC = 1, AINPUT_KEYBOARD_TYPE_ALPHABETIC = 2, _, }; -pub const AINPUT_MOTION_RANGE_X = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_X); -pub const AINPUT_MOTION_RANGE_Y = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_Y); -pub const AINPUT_MOTION_RANGE_PRESSURE = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_PRESSURE); -pub const AINPUT_MOTION_RANGE_SIZE = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_SIZE); -pub const AINPUT_MOTION_RANGE_TOUCH_MAJOR = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_TOUCH_MAJOR); -pub const AINPUT_MOTION_RANGE_TOUCH_MINOR = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_TOUCH_MINOR); -pub const AINPUT_MOTION_RANGE_TOOL_MAJOR = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_TOOL_MAJOR); -pub const AINPUT_MOTION_RANGE_TOOL_MINOR = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_TOOL_MINOR); -pub const AINPUT_MOTION_RANGE_ORIENTATION = @enumToInt(enum_unnamed_31.AINPUT_MOTION_RANGE_ORIENTATION); +pub const AINPUT_MOTION_RANGE_X = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_X); +pub const AINPUT_MOTION_RANGE_Y = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_Y); +pub const AINPUT_MOTION_RANGE_PRESSURE = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_PRESSURE); +pub const AINPUT_MOTION_RANGE_SIZE = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_SIZE); +pub const AINPUT_MOTION_RANGE_TOUCH_MAJOR = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_TOUCH_MAJOR); +pub const AINPUT_MOTION_RANGE_TOUCH_MINOR = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_TOUCH_MINOR); +pub const AINPUT_MOTION_RANGE_TOOL_MAJOR = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_TOOL_MAJOR); +pub const AINPUT_MOTION_RANGE_TOOL_MINOR = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_TOOL_MINOR); +pub const AINPUT_MOTION_RANGE_ORIENTATION = @intFromEnum(enum_unnamed_31.AINPUT_MOTION_RANGE_ORIENTATION); const enum_unnamed_31 = enum(c_int) { AINPUT_MOTION_RANGE_X = 0, AINPUT_MOTION_RANGE_Y = 1, @@ -1778,12 +1778,12 @@ pub extern fn strtoimax(__s: [*c]const u8, __end_ptr: [*c][*c]u8, __base: c_int) pub extern fn strtoumax(__s: [*c]const u8, __end_ptr: [*c][*c]u8, __base: c_int) uintmax_t; pub extern fn wcstoimax(__s: [*c]const wchar_t, __end_ptr: [*c][*c]wchar_t, __base: c_int) intmax_t; pub extern fn wcstoumax(__s: [*c]const wchar_t, __end_ptr: [*c][*c]wchar_t, __base: c_int) uintmax_t; -pub const ADATASPACE_UNKNOWN = @enumToInt(enum_ADataSpace.ADATASPACE_UNKNOWN); -pub const ADATASPACE_SCRGB_LINEAR = @enumToInt(enum_ADataSpace.ADATASPACE_SCRGB_LINEAR); -pub const ADATASPACE_SRGB = @enumToInt(enum_ADataSpace.ADATASPACE_SRGB); -pub const ADATASPACE_SCRGB = @enumToInt(enum_ADataSpace.ADATASPACE_SCRGB); -pub const ADATASPACE_DISPLAY_P3 = @enumToInt(enum_ADataSpace.ADATASPACE_DISPLAY_P3); -pub const ADATASPACE_BT2020_PQ = @enumToInt(enum_ADataSpace.ADATASPACE_BT2020_PQ); +pub const ADATASPACE_UNKNOWN = @intFromEnum(enum_ADataSpace.ADATASPACE_UNKNOWN); +pub const ADATASPACE_SCRGB_LINEAR = @intFromEnum(enum_ADataSpace.ADATASPACE_SCRGB_LINEAR); +pub const ADATASPACE_SRGB = @intFromEnum(enum_ADataSpace.ADATASPACE_SRGB); +pub const ADATASPACE_SCRGB = @intFromEnum(enum_ADataSpace.ADATASPACE_SCRGB); +pub const ADATASPACE_DISPLAY_P3 = @intFromEnum(enum_ADataSpace.ADATASPACE_DISPLAY_P3); +pub const ADATASPACE_BT2020_PQ = @intFromEnum(enum_ADataSpace.ADATASPACE_BT2020_PQ); pub const enum_ADataSpace = enum(c_int) { ADATASPACE_UNKNOWN = 0, ADATASPACE_SCRGB_LINEAR = 406913024, @@ -1800,20 +1800,20 @@ pub const struct_ARect = extern struct { bottom: i32, }; pub const ARect = struct_ARect; -pub const AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM); -pub const AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM); -pub const AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM); -pub const AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM); -pub const AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT); -pub const AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM); -pub const AHARDWAREBUFFER_FORMAT_BLOB = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_BLOB); -pub const AHARDWAREBUFFER_FORMAT_D16_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D16_UNORM); -pub const AHARDWAREBUFFER_FORMAT_D24_UNORM = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D24_UNORM); -pub const AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT); -pub const AHARDWAREBUFFER_FORMAT_D32_FLOAT = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D32_FLOAT); -pub const AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT); -pub const AHARDWAREBUFFER_FORMAT_S8_UINT = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_S8_UINT); -pub const AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = @enumToInt(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420); +pub const AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM); +pub const AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM); +pub const AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM); +pub const AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM); +pub const AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT); +pub const AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM); +pub const AHARDWAREBUFFER_FORMAT_BLOB = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_BLOB); +pub const AHARDWAREBUFFER_FORMAT_D16_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D16_UNORM); +pub const AHARDWAREBUFFER_FORMAT_D24_UNORM = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D24_UNORM); +pub const AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT); +pub const AHARDWAREBUFFER_FORMAT_D32_FLOAT = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D32_FLOAT); +pub const AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT); +pub const AHARDWAREBUFFER_FORMAT_S8_UINT = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_S8_UINT); +pub const AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = @intFromEnum(enum_AHardwareBuffer_Format.AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420); pub const enum_AHardwareBuffer_Format = enum(c_int) { AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = 1, AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM = 2, @@ -1831,44 +1831,44 @@ pub const enum_AHardwareBuffer_Format = enum(c_int) { AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = 35, _, }; -pub const AHARDWAREBUFFER_USAGE_CPU_READ_NEVER = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_NEVER); -pub const AHARDWAREBUFFER_USAGE_CPU_READ_RARELY = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_RARELY); -pub const AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN); -pub const AHARDWAREBUFFER_USAGE_CPU_READ_MASK = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_MASK); -pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER); -pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY); -pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN); -pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK); -pub const AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE); -pub const AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER); -pub const AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT); -pub const AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY); -pub const AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT); -pub const AHARDWAREBUFFER_USAGE_VIDEO_ENCODE = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VIDEO_ENCODE); -pub const AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA); -pub const AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER); -pub const AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP); -pub const AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE); -pub const AHARDWAREBUFFER_USAGE_VENDOR_0 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_0); -pub const AHARDWAREBUFFER_USAGE_VENDOR_1 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_1); -pub const AHARDWAREBUFFER_USAGE_VENDOR_2 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_2); -pub const AHARDWAREBUFFER_USAGE_VENDOR_3 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_3); -pub const AHARDWAREBUFFER_USAGE_VENDOR_4 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_4); -pub const AHARDWAREBUFFER_USAGE_VENDOR_5 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_5); -pub const AHARDWAREBUFFER_USAGE_VENDOR_6 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_6); -pub const AHARDWAREBUFFER_USAGE_VENDOR_7 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_7); -pub const AHARDWAREBUFFER_USAGE_VENDOR_8 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_8); -pub const AHARDWAREBUFFER_USAGE_VENDOR_9 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_9); -pub const AHARDWAREBUFFER_USAGE_VENDOR_10 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_10); -pub const AHARDWAREBUFFER_USAGE_VENDOR_11 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_11); -pub const AHARDWAREBUFFER_USAGE_VENDOR_12 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_12); -pub const AHARDWAREBUFFER_USAGE_VENDOR_13 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_13); -pub const AHARDWAREBUFFER_USAGE_VENDOR_14 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_14); -pub const AHARDWAREBUFFER_USAGE_VENDOR_15 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_15); -pub const AHARDWAREBUFFER_USAGE_VENDOR_16 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_16); -pub const AHARDWAREBUFFER_USAGE_VENDOR_17 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_17); -pub const AHARDWAREBUFFER_USAGE_VENDOR_18 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_18); -pub const AHARDWAREBUFFER_USAGE_VENDOR_19 = @enumToInt(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_19); +pub const AHARDWAREBUFFER_USAGE_CPU_READ_NEVER = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_NEVER); +pub const AHARDWAREBUFFER_USAGE_CPU_READ_RARELY = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_RARELY); +pub const AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN); +pub const AHARDWAREBUFFER_USAGE_CPU_READ_MASK = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_READ_MASK); +pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER); +pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY); +pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN); +pub const AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK); +pub const AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE); +pub const AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER); +pub const AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT); +pub const AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY); +pub const AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT); +pub const AHARDWAREBUFFER_USAGE_VIDEO_ENCODE = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VIDEO_ENCODE); +pub const AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA); +pub const AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER); +pub const AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP); +pub const AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE); +pub const AHARDWAREBUFFER_USAGE_VENDOR_0 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_0); +pub const AHARDWAREBUFFER_USAGE_VENDOR_1 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_1); +pub const AHARDWAREBUFFER_USAGE_VENDOR_2 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_2); +pub const AHARDWAREBUFFER_USAGE_VENDOR_3 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_3); +pub const AHARDWAREBUFFER_USAGE_VENDOR_4 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_4); +pub const AHARDWAREBUFFER_USAGE_VENDOR_5 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_5); +pub const AHARDWAREBUFFER_USAGE_VENDOR_6 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_6); +pub const AHARDWAREBUFFER_USAGE_VENDOR_7 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_7); +pub const AHARDWAREBUFFER_USAGE_VENDOR_8 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_8); +pub const AHARDWAREBUFFER_USAGE_VENDOR_9 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_9); +pub const AHARDWAREBUFFER_USAGE_VENDOR_10 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_10); +pub const AHARDWAREBUFFER_USAGE_VENDOR_11 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_11); +pub const AHARDWAREBUFFER_USAGE_VENDOR_12 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_12); +pub const AHARDWAREBUFFER_USAGE_VENDOR_13 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_13); +pub const AHARDWAREBUFFER_USAGE_VENDOR_14 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_14); +pub const AHARDWAREBUFFER_USAGE_VENDOR_15 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_15); +pub const AHARDWAREBUFFER_USAGE_VENDOR_16 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_16); +pub const AHARDWAREBUFFER_USAGE_VENDOR_17 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_17); +pub const AHARDWAREBUFFER_USAGE_VENDOR_18 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_18); +pub const AHARDWAREBUFFER_USAGE_VENDOR_19 = @intFromEnum(enum_AHardwareBuffer_UsageFlags.AHARDWAREBUFFER_USAGE_VENDOR_19); pub const enum_AHardwareBuffer_UsageFlags = enum(c_ulong) { AHARDWAREBUFFER_USAGE_CPU_READ_NEVER = 0, AHARDWAREBUFFER_USAGE_CPU_READ_RARELY = 2, @@ -1945,21 +1945,21 @@ pub extern fn AHardwareBuffer_sendHandleToUnixSocket(buffer: ?*const AHardwareBu pub extern fn AHardwareBuffer_recvHandleFromUnixSocket(socketFd: c_int, outBuffer: [*c]?*AHardwareBuffer) c_int; pub extern fn AHardwareBuffer_isSupported(desc: [*c]const AHardwareBuffer_Desc) c_int; pub extern fn AHardwareBuffer_lockAndGetInfo(buffer: ?*AHardwareBuffer, usage: u64, fence: i32, rect: [*c]const ARect, outVirtualAddress: [*c]?*anyopaque, outBytesPerPixel: [*c]i32, outBytesPerStride: [*c]i32) c_int; -pub const WINDOW_FORMAT_RGBA_8888 = @enumToInt(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGBA_8888); -pub const WINDOW_FORMAT_RGBX_8888 = @enumToInt(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGBX_8888); -pub const WINDOW_FORMAT_RGB_565 = @enumToInt(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGB_565); +pub const WINDOW_FORMAT_RGBA_8888 = @intFromEnum(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGBA_8888); +pub const WINDOW_FORMAT_RGBX_8888 = @intFromEnum(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGBX_8888); +pub const WINDOW_FORMAT_RGB_565 = @intFromEnum(enum_ANativeWindow_LegacyFormat.WINDOW_FORMAT_RGB_565); pub const enum_ANativeWindow_LegacyFormat = enum(c_int) { WINDOW_FORMAT_RGBA_8888 = 1, WINDOW_FORMAT_RGBX_8888 = 2, WINDOW_FORMAT_RGB_565 = 4, _, }; -pub const ANATIVEWINDOW_TRANSFORM_IDENTITY = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_IDENTITY); -pub const ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL); -pub const ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL); -pub const ANATIVEWINDOW_TRANSFORM_ROTATE_90 = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_90); -pub const ANATIVEWINDOW_TRANSFORM_ROTATE_180 = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_180); -pub const ANATIVEWINDOW_TRANSFORM_ROTATE_270 = @enumToInt(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_270); +pub const ANATIVEWINDOW_TRANSFORM_IDENTITY = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_IDENTITY); +pub const ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL); +pub const ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL); +pub const ANATIVEWINDOW_TRANSFORM_ROTATE_90 = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_90); +pub const ANATIVEWINDOW_TRANSFORM_ROTATE_180 = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_180); +pub const ANATIVEWINDOW_TRANSFORM_ROTATE_270 = @intFromEnum(enum_ANativeWindowTransform.ANATIVEWINDOW_TRANSFORM_ROTATE_270); pub const enum_ANativeWindowTransform = enum(c_int) { ANATIVEWINDOW_TRANSFORM_IDENTITY = 0, ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL = 1, @@ -2026,16 +2026,16 @@ pub const ANativeActivity_createFunc = *const fn ([*c]ANativeActivity, ?*anyopaq pub extern fn ANativeActivity_finish(activity: [*c]ANativeActivity) void; pub extern fn ANativeActivity_setWindowFormat(activity: [*c]ANativeActivity, format: i32) void; pub extern fn ANativeActivity_setWindowFlags(activity: [*c]ANativeActivity, addFlags: u32, removeFlags: u32) void; -pub const ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT = @enumToInt(enum_unnamed_33.ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT); -pub const ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED = @enumToInt(enum_unnamed_33.ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED); +pub const ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT = @intFromEnum(enum_unnamed_33.ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT); +pub const ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED = @intFromEnum(enum_unnamed_33.ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED); const enum_unnamed_33 = enum(c_int) { ANATIVEACTIVITY_SHOW_SOFT_INPUT_IMPLICIT = 1, ANATIVEACTIVITY_SHOW_SOFT_INPUT_FORCED = 2, _, }; pub extern fn ANativeActivity_showSoftInput(activity: [*c]ANativeActivity, flags: u32) void; -pub const ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY = @enumToInt(enum_unnamed_34.ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY); -pub const ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS = @enumToInt(enum_unnamed_34.ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS); +pub const ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY = @intFromEnum(enum_unnamed_34.ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY); +pub const ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS = @intFromEnum(enum_unnamed_34.ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS); const enum_unnamed_34 = enum(c_int) { ANATIVEACTIVITY_HIDE_SOFT_INPUT_IMPLICIT_ONLY = 1, ANATIVEACTIVITY_HIDE_SOFT_INPUT_NOT_ALWAYS = 2, diff --git a/src/android-support.zig b/src/android-support.zig index 81d155e..68c6c48 100644 --- a/src/android-support.zig +++ b/src/android-support.zig @@ -30,7 +30,7 @@ export fn ANativeActivity_onCreate(activity: *android.ANativeActivity, savedStat if (len <= 0) { sdk_version = 0; } else { - const str = sdk_ver_str[0..@intCast(usize, len)]; + const str = sdk_ver_str[0..@intCast(len)]; sdk_version = std.fmt.parseInt(c_int, str, 10) catch 0; } } @@ -229,7 +229,7 @@ fn makeNativeActivityGlue(comptime App: type) android.ANativeActivityCallbacks { fn invoke(activity: *android.ANativeActivity, comptime func: []const u8, args: anytype) void { if (@hasDecl(App, func)) { if (activity.instance) |instance| { - const result = @call(.auto, @field(App, func), .{@ptrCast(*App, @alignCast(@alignOf(App), instance))} ++ args); + const result = @call(.auto, @field(App, func), .{@as(*App, @ptrCast(@alignCast(instance)))} ++ args); switch (@typeInfo(@TypeOf(result))) { .ErrorUnion => result catch |err| app_log.err("{s} returned error {s}", .{ func, @errorName(err) }), .Void => {}, @@ -247,7 +247,7 @@ fn makeNativeActivityGlue(comptime App: type) android.ANativeActivityCallbacks { outSize.* = 0; if (@hasDecl(App, "onSaveInstanceState")) { if (activity.instance) |instance| { - const optional_slice = @ptrCast(*App, @alignCast(@alignOf(App), instance)).onSaveInstanceState(std.heap.c_allocator); + const optional_slice = @as(*App, @ptrCast(@alignCast(instance))).onSaveInstanceState(std.heap.c_allocator); if (optional_slice) |slice| { outSize.* = slice.len; return slice.ptr; @@ -261,7 +261,7 @@ fn makeNativeActivityGlue(comptime App: type) android.ANativeActivityCallbacks { fn onDestroy(activity: *android.ANativeActivity) callconv(.C) void { if (activity.instance) |instance| { - const app = @ptrCast(*App, @alignCast(@alignOf(App), instance)); + const app = @as(*App, @ptrCast(@alignCast(instance))); app.deinit(); std.heap.c_allocator.destroy(app); } diff --git a/src/audio.zig b/src/audio.zig index 89eae5f..4637f92 100644 --- a/src/audio.zig +++ b/src/audio.zig @@ -11,7 +11,7 @@ const OpenSL = if (build_options.enable_opensl) @import("opensl.zig").OpenSL els const AAudio = if (build_options.enable_aaudio) @import("aaudio.zig").AAudio else Dummy; pub fn midiToFreq(note: usize) f64 { - return std.math.pow(f64, 2, (@intToFloat(f64, note) - 49) / 12) * 440; + return std.math.pow(f64, 2, (@as(f64, @floatFromInt(note)) - 49) / 12) * 440; } pub fn amplitudeTodB(amplitude: f64) f64 { diff --git a/src/egl.zig b/src/egl.zig index 678108b..ba43e39 100644 --- a/src/egl.zig +++ b/src/egl.zig @@ -20,7 +20,7 @@ pub const EGLContext = struct { pub fn init(window: *android.ANativeWindow, version: Version) !Self { const EGLint = c.EGLint; - var egl_display = c.eglGetDisplay(null); + const egl_display = c.eglGetDisplay(null); if (egl_display == null) { log.err("Error: No display found!\n", .{}); return error.FailedToInitializeEGL; @@ -87,7 +87,7 @@ pub const EGLContext = struct { log.info("Context created: {?}\n", .{context}); - var native_window: c.EGLNativeWindowType = @ptrCast(c.EGLNativeWindowType, window); // this is safe, just a C import problem + const native_window: c.EGLNativeWindowType = @ptrCast(window); // this is safe, just a C import problem const android_width = android.ANativeWindow_getWidth(window); const android_height = android.ANativeWindow_getHeight(window); diff --git a/src/jni.zig b/src/jni.zig index 60c31b7..d27285f 100644 --- a/src/jni.zig +++ b/src/jni.zig @@ -15,7 +15,7 @@ pub const JNI = opaque { } pub inline fn invokeJniNoException(jni: *JNI, comptime function: @TypeOf(.literal), args: anytype) JniReturnType(function) { - const env = @ptrCast(*android.JNIEnv, @alignCast(@alignOf(*android.JNIEnv), jni)); + const env = @as(*android.JNIEnv, @ptrCast(@alignCast(jni))); return @call( .auto, @field(env.*, @tagName(function)), @@ -135,7 +135,7 @@ pub const JNI = opaque { pub fn init(jni: *JNI, string: android.jstring) Error!String { const len = try jni.invokeJni(.GetStringLength, .{string}); const ptr = try jni.invokeJni(.GetStringChars, .{ string, null }); - const slice = ptr[0..@intCast(usize, len)]; + const slice = ptr[0..@intCast(len)]; return String{ .jstring = string, .slice = slice, diff --git a/src/opensl.zig b/src/opensl.zig index 1192bed..652ffb6 100644 --- a/src/opensl.zig +++ b/src/opensl.zig @@ -54,21 +54,21 @@ pub const OpenSL = struct { try checkResult(output_stream.player.*.*.GetInterface.?( output_stream.player, c.SL_IID_PLAY, - @ptrCast(*anyopaque, &output_stream.play_itf), + @as(*anyopaque, @ptrCast(&output_stream.play_itf)), )); // Get buffer queue interface try checkResult(output_stream.player.*.*.GetInterface.?( output_stream.player, c.SL_IID_ANDROIDSIMPLEBUFFERQUEUE, - @ptrCast(*anyopaque, &output_stream.buffer_queue_itf), + @as(*anyopaque, @ptrCast(&output_stream.buffer_queue_itf)), )); // Register callback try checkResult(output_stream.buffer_queue_itf.*.*.RegisterCallback.?( output_stream.buffer_queue_itf, bufferQueueCallback, - @ptrCast(*anyopaque, output_stream), + @as(*anyopaque, @ptrCast(output_stream)), )); // Enqueue a few buffers to get the ball rollng @@ -77,7 +77,7 @@ pub const OpenSL = struct { try checkResult(output_stream.buffer_queue_itf.*.*.Enqueue.?( output_stream.buffer_queue_itf, &output_stream.buffer[output_stream.buffer_index], - @intCast(u32, output_stream.config.buffer_size.? * (output_stream.pcm.containerSize / 8)), + @as(u32, @intCast(output_stream.config.buffer_size.? * (output_stream.pcm.containerSize / 8))), )); output_stream.buffer_index += output_stream.config.buffer_size.?; } @@ -92,19 +92,19 @@ pub const OpenSL = struct { }; pub fn bufferQueueCallback(queue_itf: c.SLAndroidSimpleBufferQueueItf, user_data: ?*anyopaque) callconv(.C) void { - var output_stream = @ptrCast(*OutputStream, @alignCast(@alignOf(OutputStream), user_data)); + var output_stream = @as(*OutputStream, @ptrCast(@alignCast(user_data))); // Lock the mutex to prevent race conditions output_stream.mutex.lock(); defer output_stream.mutex.unlock(); - var buffer = output_stream.buffer[output_stream.buffer_index .. output_stream.buffer_index + output_stream.config.buffer_size.?]; + const buffer = output_stream.buffer[output_stream.buffer_index .. output_stream.buffer_index + output_stream.config.buffer_size.?]; for (buffer) |*frame| { frame.* = 0; } - var stream_layout = StreamLayout{ + const stream_layout = StreamLayout{ .sample_rate = output_stream.pcm.samplesPerSec / 1000, .channel_count = output_stream.pcm.numChannels, .buffer = .{ .Int16 = buffer }, @@ -114,8 +114,8 @@ pub const OpenSL = struct { checkResult(queue_itf.*.*.Enqueue.?( queue_itf, - @ptrCast(*anyopaque, buffer.ptr), - @intCast(c.SLuint32, (output_stream.pcm.containerSize / 8) * buffer.len), + @as(*anyopaque, @ptrCast(buffer.ptr)), + @as(c.SLuint32, @intCast((output_stream.pcm.containerSize / 8) * buffer.len)), )) catch |e| { audio_log.err("Error enqueueing buffer! {s}", .{@errorName(e)}); }; @@ -137,7 +137,7 @@ pub const OpenSL = struct { errdefer engine_object.*.*.Destroy.?(engine_object); // Get engine interface - try checkResult(engine_object.*.*.GetInterface.?(engine_object, c.SL_IID_ENGINE, @ptrCast(*anyopaque, &engine))); + try checkResult(engine_object.*.*.GetInterface.?(engine_object, c.SL_IID_ENGINE, @as(*anyopaque, @ptrCast(&engine)))); try printEngineInterfaces(); try printEngineExtensions(); @@ -147,7 +147,7 @@ pub const OpenSL = struct { errdefer output_mix.*.*.Destroy.?(output_mix); // Get OutputMix interface - try checkResult(output_mix.*.*.GetInterface.?(output_mix, c.SL_IID_OUTPUTMIX, @ptrCast(*anyopaque, &output_mix_itf))); + try checkResult(output_mix.*.*.GetInterface.?(output_mix, c.SL_IID_OUTPUTMIX, @as(*anyopaque, @ptrCast(&output_mix_itf)))); } } @@ -175,7 +175,7 @@ pub const OpenSL = struct { // Allocate memory for audio buffer // TODO: support other formats - var buffers = try allocator.alloc(i16, config.buffer_size.? * config.buffer_count); + const buffers = try allocator.alloc(i16, config.buffer_size.? * config.buffer_count); errdefer allocator.free(buffers); for (buffers) |*sample| { @@ -201,11 +201,11 @@ pub const OpenSL = struct { // Setup the format of the content in the buffer queue .buffer_queue = .{ .locatorType = c.SL_DATALOCATOR_BUFFERQUEUE, - .numBuffers = @intCast(u32, config.buffer_count), + .numBuffers = @as(u32, @intCast(config.buffer_count)), }, .pcm = .{ .formatType = c.SL_DATAFORMAT_PCM, - .numChannels = @intCast(u32, config.channel_count), + .numChannels = @as(u32, @intCast(config.channel_count)), .samplesPerSec = config.sample_rate.? * 1000, // OpenSL ES uses milliHz instead of Hz, for some reason .bitsPerSample = switch (config.sample_format) { .Uint8 => c.SL_PCMSAMPLEFORMAT_FIXED_8, @@ -224,8 +224,8 @@ pub const OpenSL = struct { // Configure audio source .audio_source = .{ - .pFormat = @ptrCast(*anyopaque, &output_stream.pcm), - .pLocator = @ptrCast(*anyopaque, &output_stream.buffer_queue), + .pFormat = @as(*anyopaque, @ptrCast(&output_stream.pcm)), + .pLocator = @as(*anyopaque, @ptrCast(&output_stream.buffer_queue)), }, .locator_outputmix = .{ .locatorType = c.SL_DATALOCATOR_OUTPUTMIX, @@ -233,7 +233,7 @@ pub const OpenSL = struct { }, // Configure audio output .audio_sink = .{ - .pLocator = @ptrCast(*anyopaque, &output_stream.locator_outputmix), + .pLocator = @as(*anyopaque, @ptrCast(&output_stream.locator_outputmix)), .pFormat = null, }, @@ -350,7 +350,7 @@ pub const OpenSL = struct { var extension_ptr: [4096]u8 = undefined; var extension_size: c.SLint16 = 4096; try checkResult(engine.*.*.QuerySupportedExtension.?(engine, i, &extension_ptr, &extension_size)); - var extension_name = extension_ptr[0..@intCast(usize, extension_size)]; + const extension_name = extension_ptr[0..@as(usize, @intCast(extension_size))]; audio_log.info("OpenSL engine extension {}: {s}", .{ i, extension_name }); } } From e284cd166e161c7c6f57ea997b595ce455a853b3 Mon Sep 17 00:00:00 2001 From: Felipe Jorge Date: Sun, 17 Dec 2023 10:23:04 -0300 Subject: [PATCH 4/7] fix opensles dependency loop --- Sdk.zig | 8 +- build.zig | 2 +- src/OpenSLES.zig | 2456 ++++++++++++++++++++++++++++++++++++++++++++++ src/c.zig | 6 +- 4 files changed, 2464 insertions(+), 8 deletions(-) create mode 100644 src/OpenSLES.zig diff --git a/Sdk.zig b/Sdk.zig index 6d22fe2..839a03b 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -595,9 +595,6 @@ pub fn createApp( align_step.step.dependOn(&make_unsigned_apk.step); const apk_file = align_step.addOutputFileArg(apk_filename); - const apk_install = sdk.b.addInstallBinFile(apk_file, apk_filename); - sdk.b.getInstallStep().dependOn(&apk_install.step); - const java_dir = sdk.b.getInstallPath(.lib, "java"); if (java_files_opt) |java_files| { const d8_cmd_builder = sdk.b.addSystemCommand(&[_][]const u8{sdk.system_tools.d8}); @@ -657,6 +654,11 @@ pub fn createApp( sign_step.addFileArg(apk_file); } + const apk_install = sdk.b.addInstallBinFile(apk_file, apk_filename); + sdk.b.getInstallStep().dependOn(&apk_install.step); + // only install after singing the apk + apk_install.step.dependOn(&sign_step.step); + inline for (std.meta.fields(AppTargetConfig)) |fld| { const target_name = @field(Target, fld.name); if (@field(targets, fld.name).?) { diff --git a/build.zig b/build.zig index 1c6682d..ea7a0e4 100644 --- a/build.zig +++ b/build.zig @@ -11,7 +11,7 @@ pub fn build(b: *std.build.Builder) !void { const mode = b.standardOptimizeOption(.{}); const android_version = b.option(Sdk.AndroidVersion, "android", "Select the android version, default is 'android5'") orelse .android5; const aaudio = b.option(bool, "aaudio", "Compile with support for AAudio, default is 'false'") orelse false; - const opensl = b.option(bool, "opensl", "Compile with support for OpenSL ES, default is 'false'") orelse false; + const opensl = b.option(bool, "opensl", "Compile with support for OpenSL ES, default is 'true'") orelse true; // Provide some KeyStore structure so we can sign our app. // Recommendation: Don't hardcore your password here, everyone can read it. diff --git a/src/OpenSLES.zig b/src/OpenSLES.zig new file mode 100644 index 0000000..aa5de73 --- /dev/null +++ b/src/OpenSLES.zig @@ -0,0 +1,2456 @@ +const std = @import("std"); + +pub const __builtin_object_size = std.zig.c_builtins.__builtin_object_size; +pub const __builtin_expect = std.zig.c_builtins.__builtin_expect; +pub const __builtin_constant_p = std.zig.c_builtins.__builtin_constant_p; + +pub const sl_uint8_t = u8; +pub const sl_int8_t = i8; +pub const sl_uint16_t = c_ushort; +pub const sl_int16_t = c_short; +pub const sl_uint32_t = c_uint; +pub const sl_int32_t = c_int; +pub const sl_int64_t = c_longlong; +pub const sl_uint64_t = c_ulonglong; +pub const SLint8 = sl_int8_t; +pub const SLuint8 = sl_uint8_t; +pub const SLint16 = sl_int16_t; +pub const SLuint16 = sl_uint16_t; +pub const SLint32 = sl_int32_t; +pub const SLuint32 = sl_uint32_t; +pub const SLboolean = SLuint32; +pub const SLchar = SLuint8; +pub const SLmillibel = SLint16; +pub const SLmillisecond = SLuint32; +pub const SLmilliHertz = SLuint32; +pub const SLmillimeter = SLint32; +pub const SLmillidegree = SLint32; +pub const SLpermille = SLint16; +pub const SLmicrosecond = SLuint32; +pub const SLresult = SLuint32; +pub const struct_SLInterfaceID_ = extern struct { + time_low: SLuint32 = std.mem.zeroes(SLuint32), + time_mid: SLuint16 = std.mem.zeroes(SLuint16), + time_hi_and_version: SLuint16 = std.mem.zeroes(SLuint16), + clock_seq: SLuint16 = std.mem.zeroes(SLuint16), + node: [6]SLuint8 = std.mem.zeroes([6]SLuint8), +}; +pub const SLInterfaceID = [*c]const struct_SLInterfaceID_; +pub const SLObjectItf = [*c]const [*c]const struct_SLObjectItf_; +pub const slObjectCallback = ?*const fn ([*c]const [*c]const struct_SLObjectItf_, ?*const anyopaque, SLuint32, SLresult, SLuint32, ?*anyopaque) callconv(.C) void; +pub const struct_SLObjectItf_ = extern struct { + Realize: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLboolean) callconv(.C) SLresult), + Resume: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLboolean) callconv(.C) SLresult), + GetState: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, [*c]SLuint32) callconv(.C) SLresult), + GetInterface: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLInterfaceID, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLInterfaceID, ?*anyopaque) callconv(.C) SLresult), + RegisterCallback: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, slObjectCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, slObjectCallback, ?*anyopaque) callconv(.C) SLresult), + AbortAsyncOperation: ?*const fn ([*c]const [*c]const struct_SLObjectItf_) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_) callconv(.C) void), + Destroy: ?*const fn ([*c]const [*c]const struct_SLObjectItf_) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_) callconv(.C) void), + SetPriority: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLint32, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLint32, SLboolean) callconv(.C) SLresult), + GetPriority: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, [*c]SLint32, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, [*c]SLint32, [*c]SLboolean) callconv(.C) SLresult), + SetLossOfControlInterfaces: ?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLint16, [*c]SLInterfaceID, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLObjectItf_, SLint16, [*c]SLInterfaceID, SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_NULL: SLInterfaceID; +pub const struct_SLDataLocator_URI_ = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + URI: [*c]SLchar = std.mem.zeroes([*c]SLchar), +}; +pub const SLDataLocator_URI = struct_SLDataLocator_URI_; +pub const struct_SLDataLocator_Address_ = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + pAddress: ?*anyopaque = std.mem.zeroes(?*anyopaque), + length: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataLocator_Address = struct_SLDataLocator_Address_; +pub const struct_SLDataLocator_IODevice_ = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + deviceType: SLuint32 = std.mem.zeroes(SLuint32), + deviceID: SLuint32 = std.mem.zeroes(SLuint32), + device: [*c]const [*c]const struct_SLObjectItf_ = std.mem.zeroes([*c]const [*c]const struct_SLObjectItf_), +}; +pub const SLDataLocator_IODevice = struct_SLDataLocator_IODevice_; +pub const struct_SLDataLocator_OutputMix = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + outputMix: [*c]const [*c]const struct_SLObjectItf_ = std.mem.zeroes([*c]const [*c]const struct_SLObjectItf_), +}; +pub const SLDataLocator_OutputMix = struct_SLDataLocator_OutputMix; +pub const struct_SLDataLocator_BufferQueue = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + numBuffers: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataLocator_BufferQueue = struct_SLDataLocator_BufferQueue; +pub const struct_SLDataLocator_MIDIBufferQueue = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + tpqn: SLuint32 = std.mem.zeroes(SLuint32), + numBuffers: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataLocator_MIDIBufferQueue = struct_SLDataLocator_MIDIBufferQueue; +pub const struct_SLDataFormat_MIME_ = extern struct { + formatType: SLuint32 = std.mem.zeroes(SLuint32), + mimeType: [*c]SLchar = std.mem.zeroes([*c]SLchar), + containerType: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataFormat_MIME = struct_SLDataFormat_MIME_; +pub const struct_SLDataFormat_PCM_ = extern struct { + formatType: SLuint32 = std.mem.zeroes(SLuint32), + numChannels: SLuint32 = std.mem.zeroes(SLuint32), + samplesPerSec: SLuint32 = std.mem.zeroes(SLuint32), + bitsPerSample: SLuint32 = std.mem.zeroes(SLuint32), + containerSize: SLuint32 = std.mem.zeroes(SLuint32), + channelMask: SLuint32 = std.mem.zeroes(SLuint32), + endianness: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataFormat_PCM = struct_SLDataFormat_PCM_; +pub const struct_SLDataSource_ = extern struct { + pLocator: ?*anyopaque = std.mem.zeroes(?*anyopaque), + pFormat: ?*anyopaque = std.mem.zeroes(?*anyopaque), +}; +pub const SLDataSource = struct_SLDataSource_; +pub const struct_SLDataSink_ = extern struct { + pLocator: ?*anyopaque = std.mem.zeroes(?*anyopaque), + pFormat: ?*anyopaque = std.mem.zeroes(?*anyopaque), +}; +pub const SLDataSink = struct_SLDataSink_; +pub extern const SL_IID_OBJECT: SLInterfaceID; +pub const struct_SLAudioInputDescriptor_ = extern struct { + deviceName: [*c]SLchar = std.mem.zeroes([*c]SLchar), + deviceConnection: SLint16 = std.mem.zeroes(SLint16), + deviceScope: SLint16 = std.mem.zeroes(SLint16), + deviceLocation: SLint16 = std.mem.zeroes(SLint16), + isForTelephony: SLboolean = std.mem.zeroes(SLboolean), + minSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + maxSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + isFreqRangeContinuous: SLboolean = std.mem.zeroes(SLboolean), + samplingRatesSupported: [*c]SLmilliHertz = std.mem.zeroes([*c]SLmilliHertz), + numOfSamplingRatesSupported: SLint16 = std.mem.zeroes(SLint16), + maxChannels: SLint16 = std.mem.zeroes(SLint16), +}; +pub const SLAudioInputDescriptor = struct_SLAudioInputDescriptor_; +pub const struct_SLAudioOutputDescriptor_ = extern struct { + pDeviceName: [*c]SLchar = std.mem.zeroes([*c]SLchar), + deviceConnection: SLint16 = std.mem.zeroes(SLint16), + deviceScope: SLint16 = std.mem.zeroes(SLint16), + deviceLocation: SLint16 = std.mem.zeroes(SLint16), + isForTelephony: SLboolean = std.mem.zeroes(SLboolean), + minSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + maxSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + isFreqRangeContinuous: SLboolean = std.mem.zeroes(SLboolean), + samplingRatesSupported: [*c]SLmilliHertz = std.mem.zeroes([*c]SLmilliHertz), + numOfSamplingRatesSupported: SLint16 = std.mem.zeroes(SLint16), + maxChannels: SLint16 = std.mem.zeroes(SLint16), +}; +pub const SLAudioOutputDescriptor = struct_SLAudioOutputDescriptor_; +pub extern const SL_IID_AUDIOIODEVICECAPABILITIES: SLInterfaceID; +pub const SLAudioIODeviceCapabilitiesItf = [*c]const [*c]const struct_SLAudioIODeviceCapabilitiesItf_; +pub const slAvailableAudioInputsChangedCallback = ?*const fn (SLAudioIODeviceCapabilitiesItf, ?*anyopaque, SLuint32, SLint32, SLboolean) callconv(.C) void; +pub const slAvailableAudioOutputsChangedCallback = ?*const fn (SLAudioIODeviceCapabilitiesItf, ?*anyopaque, SLuint32, SLint32, SLboolean) callconv(.C) void; +pub const slDefaultDeviceIDMapChangedCallback = ?*const fn (SLAudioIODeviceCapabilitiesItf, ?*anyopaque, SLboolean, SLint32) callconv(.C) void; +pub const struct_SLAudioIODeviceCapabilitiesItf_ = extern struct { + GetAvailableAudioInputs: ?*const fn (SLAudioIODeviceCapabilitiesItf, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + QueryAudioInputCapabilities: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLAudioInputDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLAudioInputDescriptor) callconv(.C) SLresult), + RegisterAvailableAudioInputsChangedCallback: ?*const fn (SLAudioIODeviceCapabilitiesItf, slAvailableAudioInputsChangedCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, slAvailableAudioInputsChangedCallback, ?*anyopaque) callconv(.C) SLresult), + GetAvailableAudioOutputs: ?*const fn (SLAudioIODeviceCapabilitiesItf, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + QueryAudioOutputCapabilities: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLAudioOutputDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLAudioOutputDescriptor) callconv(.C) SLresult), + RegisterAvailableAudioOutputsChangedCallback: ?*const fn (SLAudioIODeviceCapabilitiesItf, slAvailableAudioOutputsChangedCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, slAvailableAudioOutputsChangedCallback, ?*anyopaque) callconv(.C) SLresult), + RegisterDefaultDeviceIDMapChangedCallback: ?*const fn (SLAudioIODeviceCapabilitiesItf, slDefaultDeviceIDMapChangedCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, slDefaultDeviceIDMapChangedCallback, ?*anyopaque) callconv(.C) SLresult), + GetAssociatedAudioInputs: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + GetAssociatedAudioOutputs: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + GetDefaultAudioDevices: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + QuerySampleFormatsSupported: ?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, SLmilliHertz, [*c]SLint32, [*c]SLint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioIODeviceCapabilitiesItf, SLuint32, SLmilliHertz, [*c]SLint32, [*c]SLint32) callconv(.C) SLresult), +}; +pub const struct_SLLEDDescriptor_ = extern struct { + ledCount: SLuint8 = std.mem.zeroes(SLuint8), + primaryLED: SLuint8 = std.mem.zeroes(SLuint8), + colorMask: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLLEDDescriptor = struct_SLLEDDescriptor_; +pub const struct_SLHSL_ = extern struct { + hue: SLmillidegree = std.mem.zeroes(SLmillidegree), + saturation: SLpermille = std.mem.zeroes(SLpermille), + lightness: SLpermille = std.mem.zeroes(SLpermille), +}; +pub const SLHSL = struct_SLHSL_; +pub extern const SL_IID_LED: SLInterfaceID; +pub const SLLEDArrayItf = [*c]const [*c]const struct_SLLEDArrayItf_; +pub const struct_SLLEDArrayItf_ = extern struct { + ActivateLEDArray: ?*const fn (SLLEDArrayItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLLEDArrayItf, SLuint32) callconv(.C) SLresult), + IsLEDArrayActivated: ?*const fn (SLLEDArrayItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLLEDArrayItf, [*c]SLuint32) callconv(.C) SLresult), + SetColor: ?*const fn (SLLEDArrayItf, SLuint8, [*c]const SLHSL) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLLEDArrayItf, SLuint8, [*c]const SLHSL) callconv(.C) SLresult), + GetColor: ?*const fn (SLLEDArrayItf, SLuint8, [*c]SLHSL) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLLEDArrayItf, SLuint8, [*c]SLHSL) callconv(.C) SLresult), +}; +pub const struct_SLVibraDescriptor_ = extern struct { + supportsFrequency: SLboolean = std.mem.zeroes(SLboolean), + supportsIntensity: SLboolean = std.mem.zeroes(SLboolean), + minFrequency: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + maxFrequency: SLmilliHertz = std.mem.zeroes(SLmilliHertz), +}; +pub const SLVibraDescriptor = struct_SLVibraDescriptor_; +pub extern const SL_IID_VIBRA: SLInterfaceID; +pub const SLVibraItf = [*c]const [*c]const struct_SLVibraItf_; +pub const struct_SLVibraItf_ = extern struct { + Vibrate: ?*const fn (SLVibraItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, SLboolean) callconv(.C) SLresult), + IsVibrating: ?*const fn (SLVibraItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, [*c]SLboolean) callconv(.C) SLresult), + SetFrequency: ?*const fn (SLVibraItf, SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, SLmilliHertz) callconv(.C) SLresult), + GetFrequency: ?*const fn (SLVibraItf, [*c]SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, [*c]SLmilliHertz) callconv(.C) SLresult), + SetIntensity: ?*const fn (SLVibraItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, SLpermille) callconv(.C) SLresult), + GetIntensity: ?*const fn (SLVibraItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVibraItf, [*c]SLpermille) callconv(.C) SLresult), +}; +pub const struct_SLMetadataInfo_ = extern struct { + size: SLuint32 = std.mem.zeroes(SLuint32), + encoding: SLuint32 = std.mem.zeroes(SLuint32), + langCountry: [16]SLchar = std.mem.zeroes([16]SLchar), + data: [1]SLuint8 = std.mem.zeroes([1]SLuint8), +}; +pub const SLMetadataInfo = struct_SLMetadataInfo_; +pub extern const SL_IID_METADATAEXTRACTION: SLInterfaceID; +pub const SLMetadataExtractionItf = [*c]const [*c]const struct_SLMetadataExtractionItf_; +pub const struct_SLMetadataExtractionItf_ = extern struct { + GetItemCount: ?*const fn (SLMetadataExtractionItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, [*c]SLuint32) callconv(.C) SLresult), + GetKeySize: ?*const fn (SLMetadataExtractionItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult), + GetKey: ?*const fn (SLMetadataExtractionItf, SLuint32, SLuint32, [*c]SLMetadataInfo) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, SLuint32, SLuint32, [*c]SLMetadataInfo) callconv(.C) SLresult), + GetValueSize: ?*const fn (SLMetadataExtractionItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult), + GetValue: ?*const fn (SLMetadataExtractionItf, SLuint32, SLuint32, [*c]SLMetadataInfo) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, SLuint32, SLuint32, [*c]SLMetadataInfo) callconv(.C) SLresult), + AddKeyFilter: ?*const fn (SLMetadataExtractionItf, SLuint32, ?*const anyopaque, SLuint32, [*c]const SLchar, SLuint32, SLuint8) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf, SLuint32, ?*const anyopaque, SLuint32, [*c]const SLchar, SLuint32, SLuint8) callconv(.C) SLresult), + ClearKeyFilter: ?*const fn (SLMetadataExtractionItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataExtractionItf) callconv(.C) SLresult), +}; +pub extern const SL_IID_METADATATRAVERSAL: SLInterfaceID; +pub const SLMetadataTraversalItf = [*c]const [*c]const struct_SLMetadataTraversalItf_; +pub const struct_SLMetadataTraversalItf_ = extern struct { + SetMode: ?*const fn (SLMetadataTraversalItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataTraversalItf, SLuint32) callconv(.C) SLresult), + GetChildCount: ?*const fn (SLMetadataTraversalItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataTraversalItf, [*c]SLuint32) callconv(.C) SLresult), + GetChildMIMETypeSize: ?*const fn (SLMetadataTraversalItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataTraversalItf, SLuint32, [*c]SLuint32) callconv(.C) SLresult), + GetChildInfo: ?*const fn (SLMetadataTraversalItf, SLuint32, [*c]SLint32, [*c]SLuint32, SLuint32, [*c]SLchar) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataTraversalItf, SLuint32, [*c]SLint32, [*c]SLuint32, SLuint32, [*c]SLchar) callconv(.C) SLresult), + SetActiveNode: ?*const fn (SLMetadataTraversalItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMetadataTraversalItf, SLuint32) callconv(.C) SLresult), +}; +pub extern const SL_IID_DYNAMICSOURCE: SLInterfaceID; +pub const SLDynamicSourceItf = [*c]const [*c]const struct_SLDynamicSourceItf_; +pub const struct_SLDynamicSourceItf_ = extern struct { + SetSource: ?*const fn (SLDynamicSourceItf, [*c]SLDataSource) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDynamicSourceItf, [*c]SLDataSource) callconv(.C) SLresult), +}; +pub extern const SL_IID_OUTPUTMIX: SLInterfaceID; +pub const SLOutputMixItf = [*c]const [*c]const struct_SLOutputMixItf_; +pub const slMixDeviceChangeCallback = ?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, ?*anyopaque) callconv(.C) void; +pub const struct_SLOutputMixItf_ = extern struct { + GetDestinationOutputDeviceIDs: ?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, [*c]SLint32, [*c]SLuint32) callconv(.C) SLresult), + RegisterDeviceChangeCallback: ?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, slMixDeviceChangeCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, slMixDeviceChangeCallback, ?*anyopaque) callconv(.C) SLresult), + ReRoute: ?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, SLint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLOutputMixItf_, SLint32, [*c]SLuint32) callconv(.C) SLresult), +}; +pub extern const SL_IID_PLAY: SLInterfaceID; +pub const SLPlayItf = [*c]const [*c]const struct_SLPlayItf_; +pub const slPlayCallback = ?*const fn ([*c]const [*c]const struct_SLPlayItf_, ?*anyopaque, SLuint32) callconv(.C) void; +pub const struct_SLPlayItf_ = extern struct { + SetPlayState: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLuint32) callconv(.C) SLresult), + GetPlayState: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLuint32) callconv(.C) SLresult), + GetDuration: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult), + GetPosition: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult), + RegisterCallback: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, slPlayCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, slPlayCallback, ?*anyopaque) callconv(.C) SLresult), + SetCallbackEventsMask: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLuint32) callconv(.C) SLresult), + GetCallbackEventsMask: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLuint32) callconv(.C) SLresult), + SetMarkerPosition: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLmillisecond) callconv(.C) SLresult), + ClearMarkerPosition: ?*const fn ([*c]const [*c]const struct_SLPlayItf_) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_) callconv(.C) SLresult), + GetMarkerPosition: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult), + SetPositionUpdatePeriod: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, SLmillisecond) callconv(.C) SLresult), + GetPositionUpdatePeriod: ?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLPlayItf_, [*c]SLmillisecond) callconv(.C) SLresult), +}; +pub extern const SL_IID_PREFETCHSTATUS: SLInterfaceID; +pub const SLPrefetchStatusItf = [*c]const [*c]const struct_SLPrefetchStatusItf_; +pub const slPrefetchCallback = ?*const fn (SLPrefetchStatusItf, ?*anyopaque, SLuint32) callconv(.C) void; +pub const struct_SLPrefetchStatusItf_ = extern struct { + GetPrefetchStatus: ?*const fn (SLPrefetchStatusItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, [*c]SLuint32) callconv(.C) SLresult), + GetFillLevel: ?*const fn (SLPrefetchStatusItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, [*c]SLpermille) callconv(.C) SLresult), + RegisterCallback: ?*const fn (SLPrefetchStatusItf, slPrefetchCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, slPrefetchCallback, ?*anyopaque) callconv(.C) SLresult), + SetCallbackEventsMask: ?*const fn (SLPrefetchStatusItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, SLuint32) callconv(.C) SLresult), + GetCallbackEventsMask: ?*const fn (SLPrefetchStatusItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, [*c]SLuint32) callconv(.C) SLresult), + SetFillUpdatePeriod: ?*const fn (SLPrefetchStatusItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, SLpermille) callconv(.C) SLresult), + GetFillUpdatePeriod: ?*const fn (SLPrefetchStatusItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPrefetchStatusItf, [*c]SLpermille) callconv(.C) SLresult), +}; +pub extern const SL_IID_PLAYBACKRATE: SLInterfaceID; +pub const SLPlaybackRateItf = [*c]const [*c]const struct_SLPlaybackRateItf_; +pub const struct_SLPlaybackRateItf_ = extern struct { + SetRate: ?*const fn (SLPlaybackRateItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, SLpermille) callconv(.C) SLresult), + GetRate: ?*const fn (SLPlaybackRateItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, [*c]SLpermille) callconv(.C) SLresult), + SetPropertyConstraints: ?*const fn (SLPlaybackRateItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, SLuint32) callconv(.C) SLresult), + GetProperties: ?*const fn (SLPlaybackRateItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, [*c]SLuint32) callconv(.C) SLresult), + GetCapabilitiesOfRate: ?*const fn (SLPlaybackRateItf, SLpermille, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, SLpermille, [*c]SLuint32) callconv(.C) SLresult), + GetRateRange: ?*const fn (SLPlaybackRateItf, SLuint8, [*c]SLpermille, [*c]SLpermille, [*c]SLpermille, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPlaybackRateItf, SLuint8, [*c]SLpermille, [*c]SLpermille, [*c]SLpermille, [*c]SLuint32) callconv(.C) SLresult), +}; +pub extern const SL_IID_SEEK: SLInterfaceID; +pub const SLSeekItf = [*c]const [*c]const struct_SLSeekItf_; +pub const struct_SLSeekItf_ = extern struct { + SetPosition: ?*const fn (SLSeekItf, SLmillisecond, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLSeekItf, SLmillisecond, SLuint32) callconv(.C) SLresult), + SetLoop: ?*const fn (SLSeekItf, SLboolean, SLmillisecond, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLSeekItf, SLboolean, SLmillisecond, SLmillisecond) callconv(.C) SLresult), + GetLoop: ?*const fn (SLSeekItf, [*c]SLboolean, [*c]SLmillisecond, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLSeekItf, [*c]SLboolean, [*c]SLmillisecond, [*c]SLmillisecond) callconv(.C) SLresult), +}; +pub extern const SL_IID_RECORD: SLInterfaceID; +pub const SLRecordItf = [*c]const [*c]const struct_SLRecordItf_; +pub const slRecordCallback = ?*const fn (SLRecordItf, ?*anyopaque, SLuint32) callconv(.C) void; +pub const struct_SLRecordItf_ = extern struct { + SetRecordState: ?*const fn (SLRecordItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, SLuint32) callconv(.C) SLresult), + GetRecordState: ?*const fn (SLRecordItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, [*c]SLuint32) callconv(.C) SLresult), + SetDurationLimit: ?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult), + GetPosition: ?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult), + RegisterCallback: ?*const fn (SLRecordItf, slRecordCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, slRecordCallback, ?*anyopaque) callconv(.C) SLresult), + SetCallbackEventsMask: ?*const fn (SLRecordItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, SLuint32) callconv(.C) SLresult), + GetCallbackEventsMask: ?*const fn (SLRecordItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, [*c]SLuint32) callconv(.C) SLresult), + SetMarkerPosition: ?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult), + ClearMarkerPosition: ?*const fn (SLRecordItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf) callconv(.C) SLresult), + GetMarkerPosition: ?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult), + SetPositionUpdatePeriod: ?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, SLmillisecond) callconv(.C) SLresult), + GetPositionUpdatePeriod: ?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRecordItf, [*c]SLmillisecond) callconv(.C) SLresult), +}; +pub extern const SL_IID_EQUALIZER: SLInterfaceID; +pub const SLEqualizerItf = [*c]const [*c]const struct_SLEqualizerItf_; +pub const struct_SLEqualizerItf_ = extern struct { + SetEnabled: ?*const fn (SLEqualizerItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLEqualizerItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, [*c]SLboolean) callconv(.C) SLresult), + GetNumberOfBands: ?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult), + GetBandLevelRange: ?*const fn (SLEqualizerItf, [*c]SLmillibel, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, [*c]SLmillibel, [*c]SLmillibel) callconv(.C) SLresult), + SetBandLevel: ?*const fn (SLEqualizerItf, SLuint16, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16, SLmillibel) callconv(.C) SLresult), + GetBandLevel: ?*const fn (SLEqualizerItf, SLuint16, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16, [*c]SLmillibel) callconv(.C) SLresult), + GetCenterFreq: ?*const fn (SLEqualizerItf, SLuint16, [*c]SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16, [*c]SLmilliHertz) callconv(.C) SLresult), + GetBandFreqRange: ?*const fn (SLEqualizerItf, SLuint16, [*c]SLmilliHertz, [*c]SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16, [*c]SLmilliHertz, [*c]SLmilliHertz) callconv(.C) SLresult), + GetBand: ?*const fn (SLEqualizerItf, SLmilliHertz, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLmilliHertz, [*c]SLuint16) callconv(.C) SLresult), + GetCurrentPreset: ?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult), + UsePreset: ?*const fn (SLEqualizerItf, SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16) callconv(.C) SLresult), + GetNumberOfPresets: ?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, [*c]SLuint16) callconv(.C) SLresult), + GetPresetName: ?*const fn (SLEqualizerItf, SLuint16, [*c][*c]const SLchar) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEqualizerItf, SLuint16, [*c][*c]const SLchar) callconv(.C) SLresult), +}; +pub extern const SL_IID_VOLUME: SLInterfaceID; +pub const SLVolumeItf = [*c]const [*c]const struct_SLVolumeItf_; +pub const struct_SLVolumeItf_ = extern struct { + SetVolumeLevel: ?*const fn (SLVolumeItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, SLmillibel) callconv(.C) SLresult), + GetVolumeLevel: ?*const fn (SLVolumeItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, [*c]SLmillibel) callconv(.C) SLresult), + GetMaxVolumeLevel: ?*const fn (SLVolumeItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, [*c]SLmillibel) callconv(.C) SLresult), + SetMute: ?*const fn (SLVolumeItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, SLboolean) callconv(.C) SLresult), + GetMute: ?*const fn (SLVolumeItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, [*c]SLboolean) callconv(.C) SLresult), + EnableStereoPosition: ?*const fn (SLVolumeItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, SLboolean) callconv(.C) SLresult), + IsEnabledStereoPosition: ?*const fn (SLVolumeItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, [*c]SLboolean) callconv(.C) SLresult), + SetStereoPosition: ?*const fn (SLVolumeItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, SLpermille) callconv(.C) SLresult), + GetStereoPosition: ?*const fn (SLVolumeItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVolumeItf, [*c]SLpermille) callconv(.C) SLresult), +}; +pub extern const SL_IID_DEVICEVOLUME: SLInterfaceID; +pub const SLDeviceVolumeItf = [*c]const [*c]const struct_SLDeviceVolumeItf_; +pub const struct_SLDeviceVolumeItf_ = extern struct { + GetVolumeScale: ?*const fn (SLDeviceVolumeItf, SLuint32, [*c]SLint32, [*c]SLint32, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDeviceVolumeItf, SLuint32, [*c]SLint32, [*c]SLint32, [*c]SLboolean) callconv(.C) SLresult), + SetVolume: ?*const fn (SLDeviceVolumeItf, SLuint32, SLint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDeviceVolumeItf, SLuint32, SLint32) callconv(.C) SLresult), + GetVolume: ?*const fn (SLDeviceVolumeItf, SLuint32, [*c]SLint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDeviceVolumeItf, SLuint32, [*c]SLint32) callconv(.C) SLresult), +}; +pub extern const SL_IID_BUFFERQUEUE: SLInterfaceID; +pub const SLBufferQueueItf = [*c]const [*c]const struct_SLBufferQueueItf_; +pub const struct_SLBufferQueueState_ = extern struct { + count: SLuint32 = std.mem.zeroes(SLuint32), + playIndex: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLBufferQueueState = struct_SLBufferQueueState_; +pub const slBufferQueueCallback = ?*const fn (SLBufferQueueItf, ?*anyopaque) callconv(.C) void; +pub const struct_SLBufferQueueItf_ = extern struct { + Enqueue: ?*const fn (SLBufferQueueItf, ?*const anyopaque, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBufferQueueItf, ?*const anyopaque, SLuint32) callconv(.C) SLresult), + Clear: ?*const fn (SLBufferQueueItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBufferQueueItf) callconv(.C) SLresult), + GetState: ?*const fn (SLBufferQueueItf, [*c]SLBufferQueueState) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBufferQueueItf, [*c]SLBufferQueueState) callconv(.C) SLresult), + RegisterCallback: ?*const fn (SLBufferQueueItf, slBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBufferQueueItf, slBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult), +}; +pub extern const SL_IID_PRESETREVERB: SLInterfaceID; +pub const SLPresetReverbItf = [*c]const [*c]const struct_SLPresetReverbItf_; +pub const struct_SLPresetReverbItf_ = extern struct { + SetPreset: ?*const fn (SLPresetReverbItf, SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPresetReverbItf, SLuint16) callconv(.C) SLresult), + GetPreset: ?*const fn (SLPresetReverbItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPresetReverbItf, [*c]SLuint16) callconv(.C) SLresult), +}; +pub const struct_SLEnvironmentalReverbSettings_ = extern struct { + roomLevel: SLmillibel = std.mem.zeroes(SLmillibel), + roomHFLevel: SLmillibel = std.mem.zeroes(SLmillibel), + decayTime: SLmillisecond = std.mem.zeroes(SLmillisecond), + decayHFRatio: SLpermille = std.mem.zeroes(SLpermille), + reflectionsLevel: SLmillibel = std.mem.zeroes(SLmillibel), + reflectionsDelay: SLmillisecond = std.mem.zeroes(SLmillisecond), + reverbLevel: SLmillibel = std.mem.zeroes(SLmillibel), + reverbDelay: SLmillisecond = std.mem.zeroes(SLmillisecond), + diffusion: SLpermille = std.mem.zeroes(SLpermille), + density: SLpermille = std.mem.zeroes(SLpermille), +}; +pub const SLEnvironmentalReverbSettings = struct_SLEnvironmentalReverbSettings_; +pub extern const SL_IID_ENVIRONMENTALREVERB: SLInterfaceID; +pub const SLEnvironmentalReverbItf = [*c]const [*c]const struct_SLEnvironmentalReverbItf_; +pub const struct_SLEnvironmentalReverbItf_ = extern struct { + SetRoomLevel: ?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult), + GetRoomLevel: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult), + SetRoomHFLevel: ?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult), + GetRoomHFLevel: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult), + SetDecayTime: ?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult), + GetDecayTime: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult), + SetDecayHFRatio: ?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult), + GetDecayHFRatio: ?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult), + SetReflectionsLevel: ?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult), + GetReflectionsLevel: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult), + SetReflectionsDelay: ?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult), + GetReflectionsDelay: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult), + SetReverbLevel: ?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillibel) callconv(.C) SLresult), + GetReverbLevel: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillibel) callconv(.C) SLresult), + SetReverbDelay: ?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLmillisecond) callconv(.C) SLresult), + GetReverbDelay: ?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLmillisecond) callconv(.C) SLresult), + SetDiffusion: ?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult), + GetDiffusion: ?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult), + SetDensity: ?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, SLpermille) callconv(.C) SLresult), + GetDensity: ?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLpermille) callconv(.C) SLresult), + SetEnvironmentalReverbProperties: ?*const fn (SLEnvironmentalReverbItf, [*c]const SLEnvironmentalReverbSettings) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]const SLEnvironmentalReverbSettings) callconv(.C) SLresult), + GetEnvironmentalReverbProperties: ?*const fn (SLEnvironmentalReverbItf, [*c]SLEnvironmentalReverbSettings) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEnvironmentalReverbItf, [*c]SLEnvironmentalReverbSettings) callconv(.C) SLresult), +}; +pub extern const SL_IID_EFFECTSEND: SLInterfaceID; +pub const SLEffectSendItf = [*c]const [*c]const struct_SLEffectSendItf_; +pub const struct_SLEffectSendItf_ = extern struct { + EnableEffectSend: ?*const fn (SLEffectSendItf, ?*const anyopaque, SLboolean, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, ?*const anyopaque, SLboolean, SLmillibel) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLEffectSendItf, ?*const anyopaque, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, ?*const anyopaque, [*c]SLboolean) callconv(.C) SLresult), + SetDirectLevel: ?*const fn (SLEffectSendItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, SLmillibel) callconv(.C) SLresult), + GetDirectLevel: ?*const fn (SLEffectSendItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, [*c]SLmillibel) callconv(.C) SLresult), + SetSendLevel: ?*const fn (SLEffectSendItf, ?*const anyopaque, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, ?*const anyopaque, SLmillibel) callconv(.C) SLresult), + GetSendLevel: ?*const fn (SLEffectSendItf, ?*const anyopaque, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEffectSendItf, ?*const anyopaque, [*c]SLmillibel) callconv(.C) SLresult), +}; +pub extern const SL_IID_3DGROUPING: SLInterfaceID; +pub const SL3DGroupingItf = [*c]const [*c]const struct_SL3DGroupingItf_; +pub const struct_SL3DGroupingItf_ = extern struct { + Set3DGroup: ?*const fn (SL3DGroupingItf, [*c]const [*c]const struct_SLObjectItf_) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DGroupingItf, [*c]const [*c]const struct_SLObjectItf_) callconv(.C) SLresult), + Get3DGroup: ?*const fn (SL3DGroupingItf, [*c][*c]const [*c]const struct_SLObjectItf_) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DGroupingItf, [*c][*c]const [*c]const struct_SLObjectItf_) callconv(.C) SLresult), +}; +pub extern const SL_IID_3DCOMMIT: SLInterfaceID; +pub const SL3DCommitItf = [*c]const [*c]const struct_SL3DCommitItf_; +pub const struct_SL3DCommitItf_ = extern struct { + Commit: ?*const fn (SL3DCommitItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DCommitItf) callconv(.C) SLresult), + SetDeferred: ?*const fn (SL3DCommitItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DCommitItf, SLboolean) callconv(.C) SLresult), +}; +pub const struct_SLVec3D_ = extern struct { + x: SLint32 = std.mem.zeroes(SLint32), + y: SLint32 = std.mem.zeroes(SLint32), + z: SLint32 = std.mem.zeroes(SLint32), +}; +pub const SLVec3D = struct_SLVec3D_; +pub extern const SL_IID_3DLOCATION: SLInterfaceID; +pub const SL3DLocationItf = [*c]const [*c]const struct_SL3DLocationItf_; +pub const struct_SL3DLocationItf_ = extern struct { + SetLocationCartesian: ?*const fn (SL3DLocationItf, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, [*c]const SLVec3D) callconv(.C) SLresult), + SetLocationSpherical: ?*const fn (SL3DLocationItf, SLmillidegree, SLmillidegree, SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, SLmillidegree, SLmillidegree, SLmillimeter) callconv(.C) SLresult), + Move: ?*const fn (SL3DLocationItf, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, [*c]const SLVec3D) callconv(.C) SLresult), + GetLocationCartesian: ?*const fn (SL3DLocationItf, [*c]SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, [*c]SLVec3D) callconv(.C) SLresult), + SetOrientationVectors: ?*const fn (SL3DLocationItf, [*c]const SLVec3D, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, [*c]const SLVec3D, [*c]const SLVec3D) callconv(.C) SLresult), + SetOrientationAngles: ?*const fn (SL3DLocationItf, SLmillidegree, SLmillidegree, SLmillidegree) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, SLmillidegree, SLmillidegree, SLmillidegree) callconv(.C) SLresult), + Rotate: ?*const fn (SL3DLocationItf, SLmillidegree, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, SLmillidegree, [*c]const SLVec3D) callconv(.C) SLresult), + GetOrientationVectors: ?*const fn (SL3DLocationItf, [*c]SLVec3D, [*c]SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DLocationItf, [*c]SLVec3D, [*c]SLVec3D) callconv(.C) SLresult), +}; +pub extern const SL_IID_3DDOPPLER: SLInterfaceID; +pub const SL3DDopplerItf = [*c]const [*c]const struct_SL3DDopplerItf_; +pub const struct_SL3DDopplerItf_ = extern struct { + SetVelocityCartesian: ?*const fn (SL3DDopplerItf, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DDopplerItf, [*c]const SLVec3D) callconv(.C) SLresult), + SetVelocitySpherical: ?*const fn (SL3DDopplerItf, SLmillidegree, SLmillidegree, SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DDopplerItf, SLmillidegree, SLmillidegree, SLmillimeter) callconv(.C) SLresult), + GetVelocityCartesian: ?*const fn (SL3DDopplerItf, [*c]SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DDopplerItf, [*c]SLVec3D) callconv(.C) SLresult), + SetDopplerFactor: ?*const fn (SL3DDopplerItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DDopplerItf, SLpermille) callconv(.C) SLresult), + GetDopplerFactor: ?*const fn (SL3DDopplerItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DDopplerItf, [*c]SLpermille) callconv(.C) SLresult), +}; +pub extern const SL_IID_3DSOURCE: SLInterfaceID; +pub const SL3DSourceItf = [*c]const [*c]const struct_SL3DSourceItf_; +pub const struct_SL3DSourceItf_ = extern struct { + SetHeadRelative: ?*const fn (SL3DSourceItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLboolean) callconv(.C) SLresult), + GetHeadRelative: ?*const fn (SL3DSourceItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLboolean) callconv(.C) SLresult), + SetRolloffDistances: ?*const fn (SL3DSourceItf, SLmillimeter, SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLmillimeter, SLmillimeter) callconv(.C) SLresult), + GetRolloffDistances: ?*const fn (SL3DSourceItf, [*c]SLmillimeter, [*c]SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLmillimeter, [*c]SLmillimeter) callconv(.C) SLresult), + SetRolloffMaxDistanceMute: ?*const fn (SL3DSourceItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLboolean) callconv(.C) SLresult), + GetRolloffMaxDistanceMute: ?*const fn (SL3DSourceItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLboolean) callconv(.C) SLresult), + SetRolloffFactor: ?*const fn (SL3DSourceItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLpermille) callconv(.C) SLresult), + GetRolloffFactor: ?*const fn (SL3DSourceItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLpermille) callconv(.C) SLresult), + SetRoomRolloffFactor: ?*const fn (SL3DSourceItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLpermille) callconv(.C) SLresult), + GetRoomRolloffFactor: ?*const fn (SL3DSourceItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLpermille) callconv(.C) SLresult), + SetRolloffModel: ?*const fn (SL3DSourceItf, SLuint8) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLuint8) callconv(.C) SLresult), + GetRolloffModel: ?*const fn (SL3DSourceItf, [*c]SLuint8) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLuint8) callconv(.C) SLresult), + SetCone: ?*const fn (SL3DSourceItf, SLmillidegree, SLmillidegree, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, SLmillidegree, SLmillidegree, SLmillibel) callconv(.C) SLresult), + GetCone: ?*const fn (SL3DSourceItf, [*c]SLmillidegree, [*c]SLmillidegree, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DSourceItf, [*c]SLmillidegree, [*c]SLmillidegree, [*c]SLmillibel) callconv(.C) SLresult), +}; +pub extern const SL_IID_3DMACROSCOPIC: SLInterfaceID; +pub const SL3DMacroscopicItf = [*c]const [*c]const struct_SL3DMacroscopicItf_; +pub const struct_SL3DMacroscopicItf_ = extern struct { + SetSize: ?*const fn (SL3DMacroscopicItf, SLmillimeter, SLmillimeter, SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, SLmillimeter, SLmillimeter, SLmillimeter) callconv(.C) SLresult), + GetSize: ?*const fn (SL3DMacroscopicItf, [*c]SLmillimeter, [*c]SLmillimeter, [*c]SLmillimeter) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, [*c]SLmillimeter, [*c]SLmillimeter, [*c]SLmillimeter) callconv(.C) SLresult), + SetOrientationAngles: ?*const fn (SL3DMacroscopicItf, SLmillidegree, SLmillidegree, SLmillidegree) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, SLmillidegree, SLmillidegree, SLmillidegree) callconv(.C) SLresult), + SetOrientationVectors: ?*const fn (SL3DMacroscopicItf, [*c]const SLVec3D, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, [*c]const SLVec3D, [*c]const SLVec3D) callconv(.C) SLresult), + Rotate: ?*const fn (SL3DMacroscopicItf, SLmillidegree, [*c]const SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, SLmillidegree, [*c]const SLVec3D) callconv(.C) SLresult), + GetOrientationVectors: ?*const fn (SL3DMacroscopicItf, [*c]SLVec3D, [*c]SLVec3D) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SL3DMacroscopicItf, [*c]SLVec3D, [*c]SLVec3D) callconv(.C) SLresult), +}; +pub extern const SL_IID_MUTESOLO: SLInterfaceID; +pub const SLMuteSoloItf = [*c]const [*c]const struct_SLMuteSoloItf_; +pub const struct_SLMuteSoloItf_ = extern struct { + SetChannelMute: ?*const fn (SLMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult), + GetChannelMute: ?*const fn (SLMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult), + SetChannelSolo: ?*const fn (SLMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult), + GetChannelSolo: ?*const fn (SLMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult), + GetNumChannels: ?*const fn (SLMuteSoloItf, [*c]SLuint8) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMuteSoloItf, [*c]SLuint8) callconv(.C) SLresult), +}; +pub extern const SL_IID_DYNAMICINTERFACEMANAGEMENT: SLInterfaceID; +pub const SLDynamicInterfaceManagementItf = [*c]const [*c]const struct_SLDynamicInterfaceManagementItf_; +pub const slDynamicInterfaceManagementCallback = ?*const fn (SLDynamicInterfaceManagementItf, ?*anyopaque, SLuint32, SLresult, SLInterfaceID) callconv(.C) void; +pub const struct_SLDynamicInterfaceManagementItf_ = extern struct { + AddInterface: ?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID, SLboolean) callconv(.C) SLresult), + RemoveInterface: ?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID) callconv(.C) SLresult), + ResumeInterface: ?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDynamicInterfaceManagementItf, SLInterfaceID, SLboolean) callconv(.C) SLresult), + RegisterCallback: ?*const fn (SLDynamicInterfaceManagementItf, slDynamicInterfaceManagementCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLDynamicInterfaceManagementItf, slDynamicInterfaceManagementCallback, ?*anyopaque) callconv(.C) SLresult), +}; +pub extern const SL_IID_MIDIMESSAGE: SLInterfaceID; +pub const SLMIDIMessageItf = [*c]const [*c]const struct_SLMIDIMessageItf_; +pub const slMetaEventCallback = ?*const fn (SLMIDIMessageItf, ?*anyopaque, SLuint8, SLuint32, [*c]const SLuint8, SLuint32, SLuint16) callconv(.C) void; +pub const slMIDIMessageCallback = ?*const fn (SLMIDIMessageItf, ?*anyopaque, SLuint8, SLuint32, [*c]const SLuint8, SLuint32, SLuint16) callconv(.C) void; +pub const struct_SLMIDIMessageItf_ = extern struct { + SendMessage: ?*const fn (SLMIDIMessageItf, [*c]const SLuint8, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMessageItf, [*c]const SLuint8, SLuint32) callconv(.C) SLresult), + RegisterMetaEventCallback: ?*const fn (SLMIDIMessageItf, slMetaEventCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMessageItf, slMetaEventCallback, ?*anyopaque) callconv(.C) SLresult), + RegisterMIDIMessageCallback: ?*const fn (SLMIDIMessageItf, slMIDIMessageCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMessageItf, slMIDIMessageCallback, ?*anyopaque) callconv(.C) SLresult), + AddMIDIMessageCallbackFilter: ?*const fn (SLMIDIMessageItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMessageItf, SLuint32) callconv(.C) SLresult), + ClearMIDIMessageCallbackFilter: ?*const fn (SLMIDIMessageItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMessageItf) callconv(.C) SLresult), +}; +pub extern const SL_IID_MIDIMUTESOLO: SLInterfaceID; +pub const SLMIDIMuteSoloItf = [*c]const [*c]const struct_SLMIDIMuteSoloItf_; +pub const struct_SLMIDIMuteSoloItf_ = extern struct { + SetChannelMute: ?*const fn (SLMIDIMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult), + GetChannelMute: ?*const fn (SLMIDIMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult), + SetChannelSolo: ?*const fn (SLMIDIMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint8, SLboolean) callconv(.C) SLresult), + GetChannelSolo: ?*const fn (SLMIDIMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint8, [*c]SLboolean) callconv(.C) SLresult), + GetTrackCount: ?*const fn (SLMIDIMuteSoloItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, [*c]SLuint16) callconv(.C) SLresult), + SetTrackMute: ?*const fn (SLMIDIMuteSoloItf, SLuint16, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint16, SLboolean) callconv(.C) SLresult), + GetTrackMute: ?*const fn (SLMIDIMuteSoloItf, SLuint16, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint16, [*c]SLboolean) callconv(.C) SLresult), + SetTrackSolo: ?*const fn (SLMIDIMuteSoloItf, SLuint16, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint16, SLboolean) callconv(.C) SLresult), + GetTrackSolo: ?*const fn (SLMIDIMuteSoloItf, SLuint16, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDIMuteSoloItf, SLuint16, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_MIDITEMPO: SLInterfaceID; +pub const SLMIDITempoItf = [*c]const [*c]const struct_SLMIDITempoItf_; +pub const struct_SLMIDITempoItf_ = extern struct { + SetTicksPerQuarterNote: ?*const fn (SLMIDITempoItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITempoItf, SLuint32) callconv(.C) SLresult), + GetTicksPerQuarterNote: ?*const fn (SLMIDITempoItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITempoItf, [*c]SLuint32) callconv(.C) SLresult), + SetMicrosecondsPerQuarterNote: ?*const fn (SLMIDITempoItf, SLmicrosecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITempoItf, SLmicrosecond) callconv(.C) SLresult), + GetMicrosecondsPerQuarterNote: ?*const fn (SLMIDITempoItf, [*c]SLmicrosecond) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITempoItf, [*c]SLmicrosecond) callconv(.C) SLresult), +}; +pub extern const SL_IID_MIDITIME: SLInterfaceID; +pub const SLMIDITimeItf = [*c]const [*c]const struct_SLMIDITimeItf_; +pub const struct_SLMIDITimeItf_ = extern struct { + GetDuration: ?*const fn (SLMIDITimeItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITimeItf, [*c]SLuint32) callconv(.C) SLresult), + SetPosition: ?*const fn (SLMIDITimeItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITimeItf, SLuint32) callconv(.C) SLresult), + GetPosition: ?*const fn (SLMIDITimeItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITimeItf, [*c]SLuint32) callconv(.C) SLresult), + SetLoopPoints: ?*const fn (SLMIDITimeItf, SLuint32, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITimeItf, SLuint32, SLuint32) callconv(.C) SLresult), + GetLoopPoints: ?*const fn (SLMIDITimeItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLMIDITimeItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult), +}; +pub const struct_SLAudioCodecDescriptor_ = extern struct { + maxChannels: SLuint32 = std.mem.zeroes(SLuint32), + minBitsPerSample: SLuint32 = std.mem.zeroes(SLuint32), + maxBitsPerSample: SLuint32 = std.mem.zeroes(SLuint32), + minSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + maxSampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + isFreqRangeContinuous: SLboolean = std.mem.zeroes(SLboolean), + pSampleRatesSupported: [*c]SLmilliHertz = std.mem.zeroes([*c]SLmilliHertz), + numSampleRatesSupported: SLuint32 = std.mem.zeroes(SLuint32), + minBitRate: SLuint32 = std.mem.zeroes(SLuint32), + maxBitRate: SLuint32 = std.mem.zeroes(SLuint32), + isBitrateRangeContinuous: SLboolean = std.mem.zeroes(SLboolean), + pBitratesSupported: [*c]SLuint32 = std.mem.zeroes([*c]SLuint32), + numBitratesSupported: SLuint32 = std.mem.zeroes(SLuint32), + profileSetting: SLuint32 = std.mem.zeroes(SLuint32), + modeSetting: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAudioCodecDescriptor = struct_SLAudioCodecDescriptor_; +pub const struct_SLAudioCodecProfileMode_ = extern struct { + profileSetting: SLuint32 = std.mem.zeroes(SLuint32), + modeSetting: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAudioCodecProfileMode = struct_SLAudioCodecProfileMode_; +pub extern const SL_IID_AUDIODECODERCAPABILITIES: SLInterfaceID; +pub const SLAudioDecoderCapabilitiesItf = [*c]const [*c]const struct_SLAudioDecoderCapabilitiesItf_; +pub const struct_SLAudioDecoderCapabilitiesItf_ = extern struct { + GetAudioDecoders: ?*const fn (SLAudioDecoderCapabilitiesItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioDecoderCapabilitiesItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult), + GetAudioDecoderCapabilities: ?*const fn (SLAudioDecoderCapabilitiesItf, SLuint32, [*c]SLuint32, [*c]SLAudioCodecDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioDecoderCapabilitiesItf, SLuint32, [*c]SLuint32, [*c]SLAudioCodecDescriptor) callconv(.C) SLresult), +}; +pub const struct_SLAudioEncoderSettings_ = extern struct { + encoderId: SLuint32 = std.mem.zeroes(SLuint32), + channelsIn: SLuint32 = std.mem.zeroes(SLuint32), + channelsOut: SLuint32 = std.mem.zeroes(SLuint32), + sampleRate: SLmilliHertz = std.mem.zeroes(SLmilliHertz), + bitRate: SLuint32 = std.mem.zeroes(SLuint32), + bitsPerSample: SLuint32 = std.mem.zeroes(SLuint32), + rateControl: SLuint32 = std.mem.zeroes(SLuint32), + profileSetting: SLuint32 = std.mem.zeroes(SLuint32), + levelSetting: SLuint32 = std.mem.zeroes(SLuint32), + channelMode: SLuint32 = std.mem.zeroes(SLuint32), + streamFormat: SLuint32 = std.mem.zeroes(SLuint32), + encodeOptions: SLuint32 = std.mem.zeroes(SLuint32), + blockAlignment: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAudioEncoderSettings = struct_SLAudioEncoderSettings_; +pub extern const SL_IID_AUDIOENCODERCAPABILITIES: SLInterfaceID; +pub const SLAudioEncoderCapabilitiesItf = [*c]const [*c]const struct_SLAudioEncoderCapabilitiesItf_; +pub const struct_SLAudioEncoderCapabilitiesItf_ = extern struct { + GetAudioEncoders: ?*const fn (SLAudioEncoderCapabilitiesItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioEncoderCapabilitiesItf, [*c]SLuint32, [*c]SLuint32) callconv(.C) SLresult), + GetAudioEncoderCapabilities: ?*const fn (SLAudioEncoderCapabilitiesItf, SLuint32, [*c]SLuint32, [*c]SLAudioCodecDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioEncoderCapabilitiesItf, SLuint32, [*c]SLuint32, [*c]SLAudioCodecDescriptor) callconv(.C) SLresult), +}; +pub extern const SL_IID_AUDIOENCODER: SLInterfaceID; +pub const SLAudioEncoderItf = [*c]const [*c]const struct_SLAudioEncoderItf_; +pub const struct_SLAudioEncoderItf_ = extern struct { + SetEncoderSettings: ?*const fn (SLAudioEncoderItf, [*c]SLAudioEncoderSettings) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioEncoderItf, [*c]SLAudioEncoderSettings) callconv(.C) SLresult), + GetEncoderSettings: ?*const fn (SLAudioEncoderItf, [*c]SLAudioEncoderSettings) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAudioEncoderItf, [*c]SLAudioEncoderSettings) callconv(.C) SLresult), +}; +pub extern const SL_IID_BASSBOOST: SLInterfaceID; +pub const SLBassBoostItf = [*c]const [*c]const struct_SLBassBoostItf_; +pub const struct_SLBassBoostItf_ = extern struct { + SetEnabled: ?*const fn (SLBassBoostItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBassBoostItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLBassBoostItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBassBoostItf, [*c]SLboolean) callconv(.C) SLresult), + SetStrength: ?*const fn (SLBassBoostItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBassBoostItf, SLpermille) callconv(.C) SLresult), + GetRoundedStrength: ?*const fn (SLBassBoostItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBassBoostItf, [*c]SLpermille) callconv(.C) SLresult), + IsStrengthSupported: ?*const fn (SLBassBoostItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLBassBoostItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_PITCH: SLInterfaceID; +pub const SLPitchItf = [*c]const [*c]const struct_SLPitchItf_; +pub const struct_SLPitchItf_ = extern struct { + SetPitch: ?*const fn (SLPitchItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPitchItf, SLpermille) callconv(.C) SLresult), + GetPitch: ?*const fn (SLPitchItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPitchItf, [*c]SLpermille) callconv(.C) SLresult), + GetPitchCapabilities: ?*const fn (SLPitchItf, [*c]SLpermille, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLPitchItf, [*c]SLpermille, [*c]SLpermille) callconv(.C) SLresult), +}; +pub extern const SL_IID_RATEPITCH: SLInterfaceID; +pub const SLRatePitchItf = [*c]const [*c]const struct_SLRatePitchItf_; +pub const struct_SLRatePitchItf_ = extern struct { + SetRate: ?*const fn (SLRatePitchItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRatePitchItf, SLpermille) callconv(.C) SLresult), + GetRate: ?*const fn (SLRatePitchItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRatePitchItf, [*c]SLpermille) callconv(.C) SLresult), + GetRatePitchCapabilities: ?*const fn (SLRatePitchItf, [*c]SLpermille, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLRatePitchItf, [*c]SLpermille, [*c]SLpermille) callconv(.C) SLresult), +}; +pub extern const SL_IID_VIRTUALIZER: SLInterfaceID; +pub const SLVirtualizerItf = [*c]const [*c]const struct_SLVirtualizerItf_; +pub const struct_SLVirtualizerItf_ = extern struct { + SetEnabled: ?*const fn (SLVirtualizerItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVirtualizerItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLVirtualizerItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVirtualizerItf, [*c]SLboolean) callconv(.C) SLresult), + SetStrength: ?*const fn (SLVirtualizerItf, SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVirtualizerItf, SLpermille) callconv(.C) SLresult), + GetRoundedStrength: ?*const fn (SLVirtualizerItf, [*c]SLpermille) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVirtualizerItf, [*c]SLpermille) callconv(.C) SLresult), + IsStrengthSupported: ?*const fn (SLVirtualizerItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVirtualizerItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_VISUALIZATION: SLInterfaceID; +pub const SLVisualizationItf = [*c]const [*c]const struct_SLVisualizationItf_; +pub const slVisualizationCallback = ?*const fn (?*anyopaque, [*c]const SLuint8, [*c]const SLuint8, SLmilliHertz) callconv(.C) void; +pub const struct_SLVisualizationItf_ = extern struct { + RegisterVisualizationCallback: ?*const fn (SLVisualizationItf, slVisualizationCallback, ?*anyopaque, SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVisualizationItf, slVisualizationCallback, ?*anyopaque, SLmilliHertz) callconv(.C) SLresult), + GetMaxRate: ?*const fn (SLVisualizationItf, [*c]SLmilliHertz) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLVisualizationItf, [*c]SLmilliHertz) callconv(.C) SLresult), +}; +pub extern const SL_IID_ENGINE: SLInterfaceID; +pub const SLEngineItf = [*c]const [*c]const struct_SLEngineItf_; +pub const struct_SLEngineItf_ = extern struct { + CreateLEDDevice: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateVibraDevice: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateAudioPlayer: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateAudioRecorder: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateMidiPlayer: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSource, [*c]SLDataSink, [*c]SLDataSink, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, [*c]SLDataSource, [*c]SLDataSink, [*c]SLDataSink, [*c]SLDataSink, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateListener: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + Create3DGroup: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateOutputMix: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateMetadataExtractor: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, [*c]SLDataSource, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + CreateExtensionObject: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, ?*anyopaque, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c][*c]const [*c]const struct_SLObjectItf_, ?*anyopaque, SLuint32, SLuint32, [*c]const SLInterfaceID, [*c]const SLboolean) callconv(.C) SLresult), + QueryNumSupportedInterfaces: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, [*c]SLuint32) callconv(.C) SLresult), + QuerySupportedInterfaces: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, SLuint32, [*c]SLInterfaceID) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, SLuint32, [*c]SLInterfaceID) callconv(.C) SLresult), + QueryNumSupportedExtensions: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c]SLuint32) callconv(.C) SLresult), + QuerySupportedExtension: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, [*c]SLchar, [*c]SLint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, SLuint32, [*c]SLchar, [*c]SLint16) callconv(.C) SLresult), + IsExtensionSupported: ?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c]const SLchar, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLEngineItf_, [*c]const SLchar, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_ENGINECAPABILITIES: SLInterfaceID; +pub const SLEngineCapabilitiesItf = [*c]const [*c]const struct_SLEngineCapabilitiesItf_; +pub const struct_SLEngineCapabilitiesItf_ = extern struct { + QuerySupportedProfiles: ?*const fn (SLEngineCapabilitiesItf, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLuint16) callconv(.C) SLresult), + QueryAvailableVoices: ?*const fn (SLEngineCapabilitiesItf, SLuint16, [*c]SLint16, [*c]SLboolean, [*c]SLint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, SLuint16, [*c]SLint16, [*c]SLboolean, [*c]SLint16) callconv(.C) SLresult), + QueryNumberOfMIDISynthesizers: ?*const fn (SLEngineCapabilitiesItf, [*c]SLint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLint16) callconv(.C) SLresult), + QueryAPIVersion: ?*const fn (SLEngineCapabilitiesItf, [*c]SLint16, [*c]SLint16, [*c]SLint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLint16, [*c]SLint16, [*c]SLint16) callconv(.C) SLresult), + QueryLEDCapabilities: ?*const fn (SLEngineCapabilitiesItf, [*c]SLuint32, [*c]SLuint32, [*c]SLLEDDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLuint32, [*c]SLuint32, [*c]SLLEDDescriptor) callconv(.C) SLresult), + QueryVibraCapabilities: ?*const fn (SLEngineCapabilitiesItf, [*c]SLuint32, [*c]SLuint32, [*c]SLVibraDescriptor) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLuint32, [*c]SLuint32, [*c]SLVibraDescriptor) callconv(.C) SLresult), + IsThreadSafe: ?*const fn (SLEngineCapabilitiesItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLEngineCapabilitiesItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_THREADSYNC: SLInterfaceID; +pub const SLThreadSyncItf = [*c]const [*c]const struct_SLThreadSyncItf_; +pub const struct_SLThreadSyncItf_ = extern struct { + EnterCriticalSection: ?*const fn (SLThreadSyncItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLThreadSyncItf) callconv(.C) SLresult), + ExitCriticalSection: ?*const fn (SLThreadSyncItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLThreadSyncItf) callconv(.C) SLresult), +}; +pub const struct_SLEngineOption_ = extern struct { + feature: SLuint32 = std.mem.zeroes(SLuint32), + data: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLEngineOption = struct_SLEngineOption_; +pub extern fn slCreateEngine(pEngine: [*c][*c]const [*c]const struct_SLObjectItf_, numOptions: SLuint32, pEngineOptions: [*c]const SLEngineOption, numInterfaces: SLuint32, pInterfaceIds: [*c]const SLInterfaceID, pInterfaceRequired: [*c]const SLboolean) SLresult; +pub extern fn slQueryNumSupportedEngineInterfaces(pNumSupportedInterfaces: [*c]SLuint32) SLresult; +pub extern fn slQuerySupportedEngineInterfaces(index: SLuint32, pInterfaceId: [*c]SLInterfaceID) SLresult; +pub const __builtin_va_list = [*c]u8; +pub const __gnuc_va_list = __builtin_va_list; +pub const va_list = __builtin_va_list; +pub extern fn android_get_application_target_sdk_version(...) c_int; +pub extern fn android_get_device_api_level(...) c_int; +pub const ptrdiff_t = c_longlong; +pub const wchar_t = c_ushort; +pub const max_align_t = extern struct { + __clang_max_align_nonce1: c_longlong align(8) = std.mem.zeroes(c_longlong), + __clang_max_align_nonce2: c_longdouble align(16) = std.mem.zeroes(c_longdouble), +}; +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_longlong; +pub const __uint64_t = c_ulonglong; +pub const __intptr_t = c_int; +pub const __uintptr_t = c_uint; +pub const int_least8_t = i8; +pub const uint_least8_t = u8; +pub const int_least16_t = i16; +pub const uint_least16_t = u16; +pub const int_least32_t = i32; +pub const uint_least32_t = u32; +pub const int_least64_t = i64; +pub const uint_least64_t = u64; +pub const int_fast8_t = i8; +pub const uint_fast8_t = u8; +pub const int_fast64_t = i64; +pub const uint_fast64_t = u64; +pub const int_fast16_t = i32; +pub const uint_fast16_t = u32; +pub const int_fast32_t = i32; +pub const uint_fast32_t = u32; +pub const uintmax_t = u64; +pub const intmax_t = i64; +pub const jboolean = u8; +pub const jbyte = i8; +pub const jchar = u16; +pub const jshort = i16; +pub const jint = i32; +pub const jlong = i64; +pub const jfloat = f32; +pub const jdouble = f64; +pub const jsize = jint; +pub const jobject = ?*anyopaque; +pub const jclass = jobject; +pub const jstring = jobject; +pub const jarray = jobject; +pub const jobjectArray = jarray; +pub const jbooleanArray = jarray; +pub const jbyteArray = jarray; +pub const jcharArray = jarray; +pub const jshortArray = jarray; +pub const jintArray = jarray; +pub const jlongArray = jarray; +pub const jfloatArray = jarray; +pub const jdoubleArray = jarray; +pub const jthrowable = jobject; +pub const jweak = jobject; +pub const struct__jfieldID = opaque {}; +pub const jfieldID = ?*struct__jfieldID; +pub const struct__jmethodID = opaque {}; +pub const jmethodID = ?*struct__jmethodID; +pub const JavaVM = [*c]const struct_JNIInvokeInterface; +pub const union_jvalue = extern union { + z: jboolean, + b: jbyte, + c: jchar, + s: jshort, + i: jint, + j: jlong, + f: jfloat, + d: jdouble, + l: jobject, +}; +pub const jvalue = union_jvalue; +pub const JNIInvalidRefType: c_int = 0; +pub const JNILocalRefType: c_int = 1; +pub const JNIGlobalRefType: c_int = 2; +pub const JNIWeakGlobalRefType: c_int = 3; +pub const enum_jobjectRefType = c_uint; +pub const jobjectRefType = enum_jobjectRefType; +pub const struct_JNINativeInterface = extern struct { + reserved0: ?*anyopaque = std.mem.zeroes(?*anyopaque), + reserved1: ?*anyopaque = std.mem.zeroes(?*anyopaque), + reserved2: ?*anyopaque = std.mem.zeroes(?*anyopaque), + reserved3: ?*anyopaque = std.mem.zeroes(?*anyopaque), + GetVersion: ?*const fn ([*c]JNIEnv) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv) callconv(.C) jint), + DefineClass: ?*const fn ([*c]JNIEnv, [*c]const u8, jobject, [*c]const jbyte, jsize) callconv(.C) jclass = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c]const u8, jobject, [*c]const jbyte, jsize) callconv(.C) jclass), + FindClass: ?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) jclass = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) jclass), + FromReflectedMethod: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jmethodID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jmethodID), + FromReflectedField: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jfieldID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jfieldID), + ToReflectedMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, jboolean) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, jboolean) callconv(.C) jobject), + GetSuperclass: ?*const fn ([*c]JNIEnv, jclass) callconv(.C) jclass = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass) callconv(.C) jclass), + IsAssignableFrom: ?*const fn ([*c]JNIEnv, jclass, jclass) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jclass) callconv(.C) jboolean), + ToReflectedField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jboolean) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jboolean) callconv(.C) jobject), + Throw: ?*const fn ([*c]JNIEnv, jthrowable) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jthrowable) callconv(.C) jint), + ThrowNew: ?*const fn ([*c]JNIEnv, jclass, [*c]const u8) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const u8) callconv(.C) jint), + ExceptionOccurred: ?*const fn ([*c]JNIEnv) callconv(.C) jthrowable = std.mem.zeroes(?*const fn ([*c]JNIEnv) callconv(.C) jthrowable), + ExceptionDescribe: ?*const fn ([*c]JNIEnv) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv) callconv(.C) void), + ExceptionClear: ?*const fn ([*c]JNIEnv) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv) callconv(.C) void), + FatalError: ?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) void), + PushLocalFrame: ?*const fn ([*c]JNIEnv, jint) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jint) callconv(.C) jint), + PopLocalFrame: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject), + NewGlobalRef: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject), + DeleteGlobalRef: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) void), + DeleteLocalRef: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) void), + IsSameObject: ?*const fn ([*c]JNIEnv, jobject, jobject) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jobject) callconv(.C) jboolean), + NewLocalRef: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobject), + EnsureLocalCapacity: ?*const fn ([*c]JNIEnv, jint) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jint) callconv(.C) jint), + AllocObject: ?*const fn ([*c]JNIEnv, jclass) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass) callconv(.C) jobject), + NewObject: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jobject), + NewObjectV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jobject), + NewObjectA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject), + GetObjectClass: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jclass = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jclass), + IsInstanceOf: ?*const fn ([*c]JNIEnv, jobject, jclass) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass) callconv(.C) jboolean), + GetMethodID: ?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jmethodID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jmethodID), + CallObjectMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jobject), + CallObjectMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jobject), + CallObjectMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jobject), + CallBooleanMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jboolean), + CallBooleanMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jboolean), + CallBooleanMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jboolean), + CallByteMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jbyte), + CallByteMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jbyte), + CallByteMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jbyte), + CallCharMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jchar), + CallCharMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jchar), + CallCharMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jchar), + CallShortMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jshort), + CallShortMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jshort), + CallShortMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jshort), + CallIntMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jint), + CallIntMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jint), + CallIntMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jint), + CallLongMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jlong), + CallLongMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jlong), + CallLongMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jlong), + CallFloatMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jfloat), + CallFloatMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jfloat), + CallFloatMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jfloat), + CallDoubleMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) jdouble), + CallDoubleMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) jdouble), + CallDoubleMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) jdouble), + CallVoidMethod: ?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, ...) callconv(.C) void), + CallVoidMethodV: ?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, va_list) callconv(.C) void), + CallVoidMethodA: ?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jmethodID, [*c]const jvalue) callconv(.C) void), + CallNonvirtualObjectMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jobject), + CallNonvirtualObjectMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jobject), + CallNonvirtualObjectMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject), + CallNonvirtualBooleanMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jboolean), + CallNonvirtualBooleanMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jboolean), + CallNonvirtualBooleanMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jboolean), + CallNonvirtualByteMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jbyte), + CallNonvirtualByteMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jbyte), + CallNonvirtualByteMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jbyte), + CallNonvirtualCharMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jchar), + CallNonvirtualCharMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jchar), + CallNonvirtualCharMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jchar), + CallNonvirtualShortMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jshort), + CallNonvirtualShortMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jshort), + CallNonvirtualShortMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jshort), + CallNonvirtualIntMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jint), + CallNonvirtualIntMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jint), + CallNonvirtualIntMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jint), + CallNonvirtualLongMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jlong), + CallNonvirtualLongMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jlong), + CallNonvirtualLongMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jlong), + CallNonvirtualFloatMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jfloat), + CallNonvirtualFloatMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jfloat), + CallNonvirtualFloatMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jfloat), + CallNonvirtualDoubleMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) jdouble), + CallNonvirtualDoubleMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) jdouble), + CallNonvirtualDoubleMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) jdouble), + CallNonvirtualVoidMethod: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, ...) callconv(.C) void), + CallNonvirtualVoidMethodV: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, va_list) callconv(.C) void), + CallNonvirtualVoidMethodA: ?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jclass, jmethodID, [*c]const jvalue) callconv(.C) void), + GetFieldID: ?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jfieldID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jfieldID), + GetObjectField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jobject), + GetBooleanField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jboolean), + GetByteField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jbyte), + GetCharField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jchar), + GetShortField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jshort), + GetIntField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jint), + GetLongField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jlong), + GetFloatField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jfloat), + GetDoubleField: ?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID) callconv(.C) jdouble), + SetObjectField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jobject) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jobject) callconv(.C) void), + SetBooleanField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jboolean) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jboolean) callconv(.C) void), + SetByteField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jbyte) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jbyte) callconv(.C) void), + SetCharField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jchar) callconv(.C) void), + SetShortField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jshort) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jshort) callconv(.C) void), + SetIntField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jint) callconv(.C) void), + SetLongField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jlong) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jlong) callconv(.C) void), + SetFloatField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jfloat) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jfloat) callconv(.C) void), + SetDoubleField: ?*const fn ([*c]JNIEnv, jobject, jfieldID, jdouble) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject, jfieldID, jdouble) callconv(.C) void), + GetStaticMethodID: ?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jmethodID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jmethodID), + CallStaticObjectMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jobject), + CallStaticObjectMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jobject), + CallStaticObjectMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jobject), + CallStaticBooleanMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jboolean), + CallStaticBooleanMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jboolean), + CallStaticBooleanMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jboolean), + CallStaticByteMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jbyte), + CallStaticByteMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jbyte), + CallStaticByteMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jbyte), + CallStaticCharMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jchar), + CallStaticCharMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jchar), + CallStaticCharMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jchar), + CallStaticShortMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jshort), + CallStaticShortMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jshort), + CallStaticShortMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jshort), + CallStaticIntMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jint), + CallStaticIntMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jint), + CallStaticIntMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jint), + CallStaticLongMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jlong), + CallStaticLongMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jlong), + CallStaticLongMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jlong), + CallStaticFloatMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jfloat), + CallStaticFloatMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jfloat), + CallStaticFloatMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jfloat), + CallStaticDoubleMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) jdouble), + CallStaticDoubleMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) jdouble), + CallStaticDoubleMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) jdouble), + CallStaticVoidMethod: ?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, ...) callconv(.C) void), + CallStaticVoidMethodV: ?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, va_list) callconv(.C) void), + CallStaticVoidMethodA: ?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jmethodID, [*c]const jvalue) callconv(.C) void), + GetStaticFieldID: ?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jfieldID = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const u8, [*c]const u8) callconv(.C) jfieldID), + GetStaticObjectField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jobject), + GetStaticBooleanField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jboolean), + GetStaticByteField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jbyte), + GetStaticCharField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jchar), + GetStaticShortField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jshort), + GetStaticIntField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jint), + GetStaticLongField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jlong), + GetStaticFloatField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jfloat), + GetStaticDoubleField: ?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID) callconv(.C) jdouble), + SetStaticObjectField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jobject) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jobject) callconv(.C) void), + SetStaticBooleanField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jboolean) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jboolean) callconv(.C) void), + SetStaticByteField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jbyte) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jbyte) callconv(.C) void), + SetStaticCharField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jchar) callconv(.C) void), + SetStaticShortField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jshort) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jshort) callconv(.C) void), + SetStaticIntField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jint) callconv(.C) void), + SetStaticLongField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jlong) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jlong) callconv(.C) void), + SetStaticFloatField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jfloat) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jfloat) callconv(.C) void), + SetStaticDoubleField: ?*const fn ([*c]JNIEnv, jclass, jfieldID, jdouble) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, jfieldID, jdouble) callconv(.C) void), + NewString: ?*const fn ([*c]JNIEnv, [*c]const jchar, jsize) callconv(.C) jstring = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c]const jchar, jsize) callconv(.C) jstring), + GetStringLength: ?*const fn ([*c]JNIEnv, jstring) callconv(.C) jsize = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring) callconv(.C) jsize), + GetStringChars: ?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const jchar), + ReleaseStringChars: ?*const fn ([*c]JNIEnv, jstring, [*c]const jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]const jchar) callconv(.C) void), + NewStringUTF: ?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) jstring = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c]const u8) callconv(.C) jstring), + GetStringUTFLength: ?*const fn ([*c]JNIEnv, jstring) callconv(.C) jsize = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring) callconv(.C) jsize), + GetStringUTFChars: ?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const u8 = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const u8), + ReleaseStringUTFChars: ?*const fn ([*c]JNIEnv, jstring, [*c]const u8) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]const u8) callconv(.C) void), + GetArrayLength: ?*const fn ([*c]JNIEnv, jarray) callconv(.C) jsize = std.mem.zeroes(?*const fn ([*c]JNIEnv, jarray) callconv(.C) jsize), + NewObjectArray: ?*const fn ([*c]JNIEnv, jsize, jclass, jobject) callconv(.C) jobjectArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize, jclass, jobject) callconv(.C) jobjectArray), + GetObjectArrayElement: ?*const fn ([*c]JNIEnv, jobjectArray, jsize) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobjectArray, jsize) callconv(.C) jobject), + SetObjectArrayElement: ?*const fn ([*c]JNIEnv, jobjectArray, jsize, jobject) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobjectArray, jsize, jobject) callconv(.C) void), + NewBooleanArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jbooleanArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jbooleanArray), + NewByteArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jbyteArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jbyteArray), + NewCharArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jcharArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jcharArray), + NewShortArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jshortArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jshortArray), + NewIntArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jintArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jintArray), + NewLongArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jlongArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jlongArray), + NewFloatArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jfloatArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jfloatArray), + NewDoubleArray: ?*const fn ([*c]JNIEnv, jsize) callconv(.C) jdoubleArray = std.mem.zeroes(?*const fn ([*c]JNIEnv, jsize) callconv(.C) jdoubleArray), + GetBooleanArrayElements: ?*const fn ([*c]JNIEnv, jbooleanArray, [*c]jboolean) callconv(.C) [*c]jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbooleanArray, [*c]jboolean) callconv(.C) [*c]jboolean), + GetByteArrayElements: ?*const fn ([*c]JNIEnv, jbyteArray, [*c]jboolean) callconv(.C) [*c]jbyte = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbyteArray, [*c]jboolean) callconv(.C) [*c]jbyte), + GetCharArrayElements: ?*const fn ([*c]JNIEnv, jcharArray, [*c]jboolean) callconv(.C) [*c]jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jcharArray, [*c]jboolean) callconv(.C) [*c]jchar), + GetShortArrayElements: ?*const fn ([*c]JNIEnv, jshortArray, [*c]jboolean) callconv(.C) [*c]jshort = std.mem.zeroes(?*const fn ([*c]JNIEnv, jshortArray, [*c]jboolean) callconv(.C) [*c]jshort), + GetIntArrayElements: ?*const fn ([*c]JNIEnv, jintArray, [*c]jboolean) callconv(.C) [*c]jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jintArray, [*c]jboolean) callconv(.C) [*c]jint), + GetLongArrayElements: ?*const fn ([*c]JNIEnv, jlongArray, [*c]jboolean) callconv(.C) [*c]jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jlongArray, [*c]jboolean) callconv(.C) [*c]jlong), + GetFloatArrayElements: ?*const fn ([*c]JNIEnv, jfloatArray, [*c]jboolean) callconv(.C) [*c]jfloat = std.mem.zeroes(?*const fn ([*c]JNIEnv, jfloatArray, [*c]jboolean) callconv(.C) [*c]jfloat), + GetDoubleArrayElements: ?*const fn ([*c]JNIEnv, jdoubleArray, [*c]jboolean) callconv(.C) [*c]jdouble = std.mem.zeroes(?*const fn ([*c]JNIEnv, jdoubleArray, [*c]jboolean) callconv(.C) [*c]jdouble), + ReleaseBooleanArrayElements: ?*const fn ([*c]JNIEnv, jbooleanArray, [*c]jboolean, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbooleanArray, [*c]jboolean, jint) callconv(.C) void), + ReleaseByteArrayElements: ?*const fn ([*c]JNIEnv, jbyteArray, [*c]jbyte, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbyteArray, [*c]jbyte, jint) callconv(.C) void), + ReleaseCharArrayElements: ?*const fn ([*c]JNIEnv, jcharArray, [*c]jchar, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jcharArray, [*c]jchar, jint) callconv(.C) void), + ReleaseShortArrayElements: ?*const fn ([*c]JNIEnv, jshortArray, [*c]jshort, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jshortArray, [*c]jshort, jint) callconv(.C) void), + ReleaseIntArrayElements: ?*const fn ([*c]JNIEnv, jintArray, [*c]jint, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jintArray, [*c]jint, jint) callconv(.C) void), + ReleaseLongArrayElements: ?*const fn ([*c]JNIEnv, jlongArray, [*c]jlong, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jlongArray, [*c]jlong, jint) callconv(.C) void), + ReleaseFloatArrayElements: ?*const fn ([*c]JNIEnv, jfloatArray, [*c]jfloat, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jfloatArray, [*c]jfloat, jint) callconv(.C) void), + ReleaseDoubleArrayElements: ?*const fn ([*c]JNIEnv, jdoubleArray, [*c]jdouble, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jdoubleArray, [*c]jdouble, jint) callconv(.C) void), + GetBooleanArrayRegion: ?*const fn ([*c]JNIEnv, jbooleanArray, jsize, jsize, [*c]jboolean) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbooleanArray, jsize, jsize, [*c]jboolean) callconv(.C) void), + GetByteArrayRegion: ?*const fn ([*c]JNIEnv, jbyteArray, jsize, jsize, [*c]jbyte) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbyteArray, jsize, jsize, [*c]jbyte) callconv(.C) void), + GetCharArrayRegion: ?*const fn ([*c]JNIEnv, jcharArray, jsize, jsize, [*c]jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jcharArray, jsize, jsize, [*c]jchar) callconv(.C) void), + GetShortArrayRegion: ?*const fn ([*c]JNIEnv, jshortArray, jsize, jsize, [*c]jshort) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jshortArray, jsize, jsize, [*c]jshort) callconv(.C) void), + GetIntArrayRegion: ?*const fn ([*c]JNIEnv, jintArray, jsize, jsize, [*c]jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jintArray, jsize, jsize, [*c]jint) callconv(.C) void), + GetLongArrayRegion: ?*const fn ([*c]JNIEnv, jlongArray, jsize, jsize, [*c]jlong) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jlongArray, jsize, jsize, [*c]jlong) callconv(.C) void), + GetFloatArrayRegion: ?*const fn ([*c]JNIEnv, jfloatArray, jsize, jsize, [*c]jfloat) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jfloatArray, jsize, jsize, [*c]jfloat) callconv(.C) void), + GetDoubleArrayRegion: ?*const fn ([*c]JNIEnv, jdoubleArray, jsize, jsize, [*c]jdouble) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jdoubleArray, jsize, jsize, [*c]jdouble) callconv(.C) void), + SetBooleanArrayRegion: ?*const fn ([*c]JNIEnv, jbooleanArray, jsize, jsize, [*c]const jboolean) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbooleanArray, jsize, jsize, [*c]const jboolean) callconv(.C) void), + SetByteArrayRegion: ?*const fn ([*c]JNIEnv, jbyteArray, jsize, jsize, [*c]const jbyte) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jbyteArray, jsize, jsize, [*c]const jbyte) callconv(.C) void), + SetCharArrayRegion: ?*const fn ([*c]JNIEnv, jcharArray, jsize, jsize, [*c]const jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jcharArray, jsize, jsize, [*c]const jchar) callconv(.C) void), + SetShortArrayRegion: ?*const fn ([*c]JNIEnv, jshortArray, jsize, jsize, [*c]const jshort) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jshortArray, jsize, jsize, [*c]const jshort) callconv(.C) void), + SetIntArrayRegion: ?*const fn ([*c]JNIEnv, jintArray, jsize, jsize, [*c]const jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jintArray, jsize, jsize, [*c]const jint) callconv(.C) void), + SetLongArrayRegion: ?*const fn ([*c]JNIEnv, jlongArray, jsize, jsize, [*c]const jlong) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jlongArray, jsize, jsize, [*c]const jlong) callconv(.C) void), + SetFloatArrayRegion: ?*const fn ([*c]JNIEnv, jfloatArray, jsize, jsize, [*c]const jfloat) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jfloatArray, jsize, jsize, [*c]const jfloat) callconv(.C) void), + SetDoubleArrayRegion: ?*const fn ([*c]JNIEnv, jdoubleArray, jsize, jsize, [*c]const jdouble) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jdoubleArray, jsize, jsize, [*c]const jdouble) callconv(.C) void), + RegisterNatives: ?*const fn ([*c]JNIEnv, jclass, [*c]const JNINativeMethod, jint) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass, [*c]const JNINativeMethod, jint) callconv(.C) jint), + UnregisterNatives: ?*const fn ([*c]JNIEnv, jclass) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jclass) callconv(.C) jint), + MonitorEnter: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jint), + MonitorExit: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jint), + GetJavaVM: ?*const fn ([*c]JNIEnv, [*c][*c]JavaVM) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JNIEnv, [*c][*c]JavaVM) callconv(.C) jint), + GetStringRegion: ?*const fn ([*c]JNIEnv, jstring, jsize, jsize, [*c]jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, jsize, jsize, [*c]jchar) callconv(.C) void), + GetStringUTFRegion: ?*const fn ([*c]JNIEnv, jstring, jsize, jsize, [*c]u8) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, jsize, jsize, [*c]u8) callconv(.C) void), + GetPrimitiveArrayCritical: ?*const fn ([*c]JNIEnv, jarray, [*c]jboolean) callconv(.C) ?*anyopaque = std.mem.zeroes(?*const fn ([*c]JNIEnv, jarray, [*c]jboolean) callconv(.C) ?*anyopaque), + ReleasePrimitiveArrayCritical: ?*const fn ([*c]JNIEnv, jarray, ?*anyopaque, jint) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jarray, ?*anyopaque, jint) callconv(.C) void), + GetStringCritical: ?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const jchar = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]jboolean) callconv(.C) [*c]const jchar), + ReleaseStringCritical: ?*const fn ([*c]JNIEnv, jstring, [*c]const jchar) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jstring, [*c]const jchar) callconv(.C) void), + NewWeakGlobalRef: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jweak = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jweak), + DeleteWeakGlobalRef: ?*const fn ([*c]JNIEnv, jweak) callconv(.C) void = std.mem.zeroes(?*const fn ([*c]JNIEnv, jweak) callconv(.C) void), + ExceptionCheck: ?*const fn ([*c]JNIEnv) callconv(.C) jboolean = std.mem.zeroes(?*const fn ([*c]JNIEnv) callconv(.C) jboolean), + NewDirectByteBuffer: ?*const fn ([*c]JNIEnv, ?*anyopaque, jlong) callconv(.C) jobject = std.mem.zeroes(?*const fn ([*c]JNIEnv, ?*anyopaque, jlong) callconv(.C) jobject), + GetDirectBufferAddress: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) ?*anyopaque = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) ?*anyopaque), + GetDirectBufferCapacity: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jlong = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jlong), + GetObjectRefType: ?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobjectRefType = std.mem.zeroes(?*const fn ([*c]JNIEnv, jobject) callconv(.C) jobjectRefType), +}; +pub const JNIEnv = [*c]const struct_JNINativeInterface; +pub const struct_JNIInvokeInterface = extern struct { + reserved0: ?*anyopaque = std.mem.zeroes(?*anyopaque), + reserved1: ?*anyopaque = std.mem.zeroes(?*anyopaque), + reserved2: ?*anyopaque = std.mem.zeroes(?*anyopaque), + DestroyJavaVM: ?*const fn ([*c]JavaVM) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JavaVM) callconv(.C) jint), + AttachCurrentThread: ?*const fn ([*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) callconv(.C) jint), + DetachCurrentThread: ?*const fn ([*c]JavaVM) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JavaVM) callconv(.C) jint), + GetEnv: ?*const fn ([*c]JavaVM, [*c]?*anyopaque, jint) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JavaVM, [*c]?*anyopaque, jint) callconv(.C) jint), + AttachCurrentThreadAsDaemon: ?*const fn ([*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) callconv(.C) jint = std.mem.zeroes(?*const fn ([*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) callconv(.C) jint), +}; +pub const JNINativeMethod = extern struct { + name: [*c]const u8 = std.mem.zeroes([*c]const u8), + signature: [*c]const u8 = std.mem.zeroes([*c]const u8), + fnPtr: ?*anyopaque = std.mem.zeroes(?*anyopaque), +}; +pub const struct__JNIEnv = extern struct { + functions: [*c]const struct_JNINativeInterface = std.mem.zeroes([*c]const struct_JNINativeInterface), +}; +pub const struct__JavaVM = extern struct { + functions: [*c]const struct_JNIInvokeInterface = std.mem.zeroes([*c]const struct_JNIInvokeInterface), +}; +pub const C_JNIEnv = [*c]const struct_JNINativeInterface; +pub const struct_JavaVMAttachArgs = extern struct { + version: jint = std.mem.zeroes(jint), + name: [*c]const u8 = std.mem.zeroes([*c]const u8), + group: jobject = std.mem.zeroes(jobject), +}; +pub const JavaVMAttachArgs = struct_JavaVMAttachArgs; +pub const struct_JavaVMOption = extern struct { + optionString: [*c]const u8 = std.mem.zeroes([*c]const u8), + extraInfo: ?*anyopaque = std.mem.zeroes(?*anyopaque), +}; +pub const JavaVMOption = struct_JavaVMOption; +pub const struct_JavaVMInitArgs = extern struct { + version: jint = std.mem.zeroes(jint), + nOptions: jint = std.mem.zeroes(jint), + options: [*c]JavaVMOption = std.mem.zeroes([*c]JavaVMOption), + ignoreUnrecognized: jboolean = std.mem.zeroes(jboolean), +}; +pub const JavaVMInitArgs = struct_JavaVMInitArgs; +pub extern fn JNI_GetDefaultJavaVMInitArgs(?*anyopaque) jint; +pub extern fn JNI_CreateJavaVM([*c][*c]JavaVM, [*c][*c]JNIEnv, ?*anyopaque) jint; +pub extern fn JNI_GetCreatedJavaVMs([*c][*c]JavaVM, jsize, [*c]jsize) jint; +pub extern fn JNI_OnLoad(vm: [*c]JavaVM, reserved: ?*anyopaque) jint; +pub extern fn JNI_OnUnload(vm: [*c]JavaVM, reserved: ?*anyopaque) void; +pub const SLAint64 = sl_int64_t; +pub const SLAuint64 = sl_uint64_t; +pub const struct_SLAndroidDataFormat_PCM_EX_ = extern struct { + formatType: SLuint32 = std.mem.zeroes(SLuint32), + numChannels: SLuint32 = std.mem.zeroes(SLuint32), + sampleRate: SLuint32 = std.mem.zeroes(SLuint32), + bitsPerSample: SLuint32 = std.mem.zeroes(SLuint32), + containerSize: SLuint32 = std.mem.zeroes(SLuint32), + channelMask: SLuint32 = std.mem.zeroes(SLuint32), + endianness: SLuint32 = std.mem.zeroes(SLuint32), + representation: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAndroidDataFormat_PCM_EX = struct_SLAndroidDataFormat_PCM_EX_; +pub extern const SL_IID_ANDROIDEFFECT: SLInterfaceID; +pub const SLAndroidEffectItf = [*c]const [*c]const struct_SLAndroidEffectItf_; +pub const struct_SLAndroidEffectItf_ = extern struct { + CreateEffect: ?*const fn (SLAndroidEffectItf, SLInterfaceID) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectItf, SLInterfaceID) callconv(.C) SLresult), + ReleaseEffect: ?*const fn (SLAndroidEffectItf, SLInterfaceID) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectItf, SLInterfaceID) callconv(.C) SLresult), + SetEnabled: ?*const fn (SLAndroidEffectItf, SLInterfaceID, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectItf, SLInterfaceID, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLAndroidEffectItf, SLInterfaceID, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectItf, SLInterfaceID, [*c]SLboolean) callconv(.C) SLresult), + SendCommand: ?*const fn (SLAndroidEffectItf, SLInterfaceID, SLuint32, SLuint32, ?*anyopaque, [*c]SLuint32, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectItf, SLInterfaceID, SLuint32, SLuint32, ?*anyopaque, [*c]SLuint32, ?*anyopaque) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDEFFECTSEND: SLInterfaceID; +pub const SLAndroidEffectSendItf = [*c]const [*c]const struct_SLAndroidEffectSendItf_; +pub const struct_SLAndroidEffectSendItf_ = extern struct { + EnableEffectSend: ?*const fn (SLAndroidEffectSendItf, SLInterfaceID, SLboolean, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, SLInterfaceID, SLboolean, SLmillibel) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLAndroidEffectSendItf, SLInterfaceID, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, SLInterfaceID, [*c]SLboolean) callconv(.C) SLresult), + SetDirectLevel: ?*const fn (SLAndroidEffectSendItf, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, SLmillibel) callconv(.C) SLresult), + GetDirectLevel: ?*const fn (SLAndroidEffectSendItf, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, [*c]SLmillibel) callconv(.C) SLresult), + SetSendLevel: ?*const fn (SLAndroidEffectSendItf, SLInterfaceID, SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, SLInterfaceID, SLmillibel) callconv(.C) SLresult), + GetSendLevel: ?*const fn (SLAndroidEffectSendItf, SLInterfaceID, [*c]SLmillibel) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectSendItf, SLInterfaceID, [*c]SLmillibel) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDEFFECTCAPABILITIES: SLInterfaceID; +pub const SLAndroidEffectCapabilitiesItf = [*c]const [*c]const struct_SLAndroidEffectCapabilitiesItf_; +pub const struct_SLAndroidEffectCapabilitiesItf_ = extern struct { + QueryNumEffects: ?*const fn (SLAndroidEffectCapabilitiesItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectCapabilitiesItf, [*c]SLuint32) callconv(.C) SLresult), + QueryEffect: ?*const fn (SLAndroidEffectCapabilitiesItf, SLuint32, [*c]SLInterfaceID, [*c]SLInterfaceID, [*c]SLchar, [*c]SLuint16) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidEffectCapabilitiesItf, SLuint32, [*c]SLInterfaceID, [*c]SLInterfaceID, [*c]SLchar, [*c]SLuint16) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDCONFIGURATION: SLInterfaceID; +pub const SLAndroidConfigurationItf = [*c]const [*c]const struct_SLAndroidConfigurationItf_; +pub const struct_SLAndroidConfigurationItf_ = extern struct { + SetConfiguration: ?*const fn (SLAndroidConfigurationItf, [*c]const SLchar, ?*const anyopaque, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidConfigurationItf, [*c]const SLchar, ?*const anyopaque, SLuint32) callconv(.C) SLresult), + GetConfiguration: ?*const fn (SLAndroidConfigurationItf, [*c]const SLchar, [*c]SLuint32, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidConfigurationItf, [*c]const SLchar, [*c]SLuint32, ?*anyopaque) callconv(.C) SLresult), + AcquireJavaProxy: ?*const fn (SLAndroidConfigurationItf, SLuint32, [*c]jobject) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidConfigurationItf, SLuint32, [*c]jobject) callconv(.C) SLresult), + ReleaseJavaProxy: ?*const fn (SLAndroidConfigurationItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidConfigurationItf, SLuint32) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDSIMPLEBUFFERQUEUE: SLInterfaceID; +pub const SLAndroidSimpleBufferQueueItf = [*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_; +pub const struct_SLAndroidSimpleBufferQueueState_ = extern struct { + count: SLuint32 = std.mem.zeroes(SLuint32), + index: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAndroidSimpleBufferQueueState = struct_SLAndroidSimpleBufferQueueState_; +pub const slAndroidSimpleBufferQueueCallback = ?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, ?*anyopaque) callconv(.C) void; +pub const struct_SLAndroidSimpleBufferQueueItf_ = extern struct { + Enqueue: ?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, ?*const anyopaque, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, ?*const anyopaque, SLuint32) callconv(.C) SLresult), + Clear: ?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_) callconv(.C) SLresult), + GetState: ?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, [*c]SLAndroidSimpleBufferQueueState) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, [*c]SLAndroidSimpleBufferQueueState) callconv(.C) SLresult), + RegisterCallback: ?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, slAndroidSimpleBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn ([*c]const [*c]const struct_SLAndroidSimpleBufferQueueItf_, slAndroidSimpleBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDBUFFERQUEUESOURCE: SLInterfaceID; +pub const SLAndroidBufferQueueItf = [*c]const [*c]const struct_SLAndroidBufferQueueItf_; +pub const struct_SLAndroidBufferItem_ = extern struct { + itemKey: SLuint32 align(4) = std.mem.zeroes(SLuint32), + itemSize: SLuint32 = std.mem.zeroes(SLuint32), + pub fn itemData(self: anytype) std.zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = std.zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = std.zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @as(ReturnType, @ptrCast(@alignCast(@as(Intermediate, @ptrCast(self)) + 8))); + } +}; +pub const SLAndroidBufferItem = struct_SLAndroidBufferItem_; +pub const slAndroidBufferQueueCallback = ?*const fn (SLAndroidBufferQueueItf, ?*anyopaque, ?*anyopaque, ?*anyopaque, SLuint32, SLuint32, [*c]const SLAndroidBufferItem, SLuint32) callconv(.C) SLresult; +pub const struct_SLAndroidBufferQueueState_ = extern struct { + count: SLuint32 = std.mem.zeroes(SLuint32), + index: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLAndroidBufferQueueState = struct_SLAndroidBufferQueueState_; +pub const struct_SLAndroidBufferQueueItf_ = extern struct { + RegisterCallback: ?*const fn (SLAndroidBufferQueueItf, slAndroidBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf, slAndroidBufferQueueCallback, ?*anyopaque) callconv(.C) SLresult), + Clear: ?*const fn (SLAndroidBufferQueueItf) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf) callconv(.C) SLresult), + Enqueue: ?*const fn (SLAndroidBufferQueueItf, ?*anyopaque, ?*anyopaque, SLuint32, [*c]const SLAndroidBufferItem, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf, ?*anyopaque, ?*anyopaque, SLuint32, [*c]const SLAndroidBufferItem, SLuint32) callconv(.C) SLresult), + GetState: ?*const fn (SLAndroidBufferQueueItf, [*c]SLAndroidBufferQueueState) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf, [*c]SLAndroidBufferQueueState) callconv(.C) SLresult), + SetCallbackEventsMask: ?*const fn (SLAndroidBufferQueueItf, SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf, SLuint32) callconv(.C) SLresult), + GetCallbackEventsMask: ?*const fn (SLAndroidBufferQueueItf, [*c]SLuint32) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidBufferQueueItf, [*c]SLuint32) callconv(.C) SLresult), +}; +pub const struct_SLDataLocator_AndroidFD_ = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + fd: SLint32 = std.mem.zeroes(SLint32), + offset: SLAint64 = std.mem.zeroes(SLAint64), + length: SLAint64 = std.mem.zeroes(SLAint64), +}; +pub const SLDataLocator_AndroidFD = struct_SLDataLocator_AndroidFD_; +pub const struct_SLDataLocator_AndroidSimpleBufferQueue = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + numBuffers: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataLocator_AndroidSimpleBufferQueue = struct_SLDataLocator_AndroidSimpleBufferQueue; +pub const struct_SLDataLocator_AndroidBufferQueue_ = extern struct { + locatorType: SLuint32 = std.mem.zeroes(SLuint32), + numBuffers: SLuint32 = std.mem.zeroes(SLuint32), +}; +pub const SLDataLocator_AndroidBufferQueue = struct_SLDataLocator_AndroidBufferQueue_; +pub extern const SL_IID_ANDROIDACOUSTICECHOCANCELLATION: SLInterfaceID; +pub const SLAndroidAcousticEchoCancellationItf = [*c]const [*c]const struct_SLAndroidAcousticEchoCancellationItf_; +pub const struct_SLAndroidAcousticEchoCancellationItf_ = extern struct { + SetEnabled: ?*const fn (SLAndroidAcousticEchoCancellationItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidAcousticEchoCancellationItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLAndroidAcousticEchoCancellationItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidAcousticEchoCancellationItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDAUTOMATICGAINCONTROL: SLInterfaceID; +pub const SLAndroidAutomaticGainControlItf = [*c]const [*c]const struct_SLAndroidAutomaticGainControlItf_; +pub const struct_SLAndroidAutomaticGainControlItf_ = extern struct { + SetEnabled: ?*const fn (SLAndroidAutomaticGainControlItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidAutomaticGainControlItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLAndroidAutomaticGainControlItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidAutomaticGainControlItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub extern const SL_IID_ANDROIDNOISESUPPRESSION: SLInterfaceID; +pub const SLAndroidNoiseSuppressionItf = [*c]const [*c]const struct_SLAndroidNoiseSuppressionItf_; +pub const struct_SLAndroidNoiseSuppressionItf_ = extern struct { + SetEnabled: ?*const fn (SLAndroidNoiseSuppressionItf, SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidNoiseSuppressionItf, SLboolean) callconv(.C) SLresult), + IsEnabled: ?*const fn (SLAndroidNoiseSuppressionItf, [*c]SLboolean) callconv(.C) SLresult = std.mem.zeroes(?*const fn (SLAndroidNoiseSuppressionItf, [*c]SLboolean) callconv(.C) SLresult), +}; +pub const __INTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `LL`"); // (no file):89:9 +pub const __UINTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `ULL`"); // (no file):95:9 +pub const __INT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `LL`"); // (no file):193:9 +pub const __UINT32_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `U`"); // (no file):215:9 +pub const __UINT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `ULL`"); // (no file):223:9 +pub const __seg_gs = @compileError("unable to translate macro: undefined identifier `address_space`"); // (no file):351:9 +pub const __seg_fs = @compileError("unable to translate macro: undefined identifier `address_space`"); // (no file):352:9 +pub const __declspec = @compileError("unable to translate C expr: unexpected token '__attribute__'"); // (no file):412:9 +pub const _cdecl = @compileError("unable to translate macro: undefined identifier `__cdecl__`"); // (no file):413:9 +pub const __cdecl = @compileError("unable to translate macro: undefined identifier `__cdecl__`"); // (no file):414:9 +pub const _stdcall = @compileError("unable to translate macro: undefined identifier `__stdcall__`"); // (no file):415:9 +pub const __stdcall = @compileError("unable to translate macro: undefined identifier `__stdcall__`"); // (no file):416:9 +pub const _fastcall = @compileError("unable to translate macro: undefined identifier `__fastcall__`"); // (no file):417:9 +pub const __fastcall = @compileError("unable to translate macro: undefined identifier `__fastcall__`"); // (no file):418:9 +pub const _thiscall = @compileError("unable to translate macro: undefined identifier `__thiscall__`"); // (no file):419:9 +pub const __thiscall = @compileError("unable to translate macro: undefined identifier `__thiscall__`"); // (no file):420:9 +pub const _pascal = @compileError("unable to translate macro: undefined identifier `__pascal__`"); // (no file):421:9 +pub const __pascal = @compileError("unable to translate macro: undefined identifier `__pascal__`"); // (no file):422:9 +pub const SL_API_DEPRECATED = @compileError("unable to translate macro: undefined identifier `availability`"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES_Platform.h:58:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_DEFAULT = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1441:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_GENERIC = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1443:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_PADDEDCELL = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1445:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_ROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1447:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_BATHROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1449:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_LIVINGROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1451:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_STONEROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1453:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_AUDITORIUM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1455:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_CONCERTHALL = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1457:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_CAVE = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1459:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_ARENA = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1461:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_HANGAR = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1463:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_CARPETEDHALLWAY = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1465:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_HALLWAY = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1467:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1469:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_ALLEY = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1471:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_FOREST = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1473:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_CITY = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1475:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_MOUNTAINS = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1477:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_QUARRY = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1479:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_PLAIN = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1481:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_PARKINGLOT = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1483:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_SEWERPIPE = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1485:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_UNDERWATER = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1487:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_SMALLROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1489:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1491:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_LARGEROOM = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1493:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMHALL = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1495:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_LARGEHALL = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1497:9 +pub const SL_I3DL2_ENVIRONMENT_PRESET_PLATE = @compileError("unable to translate C expr: unexpected token '{'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES.h:1499:9 +pub const SL_ANDROID_KEY_RECORDING_PRESET = @compileError("unable to translate C expr: unexpected token 'const'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES_AndroidConfiguration.h:30:9 +pub const SL_ANDROID_KEY_STREAM_TYPE = @compileError("unable to translate C expr: unexpected token 'const'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES_AndroidConfiguration.h:54:9 +pub const SL_ANDROID_KEY_PERFORMANCE_MODE = @compileError("unable to translate C expr: unexpected token 'const'"); // d:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include\SLES/OpenSLES_AndroidConfiguration.h:86:9 +pub const va_start = @compileError("unable to translate macro: undefined identifier `__builtin_va_start`"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stdarg.h:33:9 +pub const va_end = @compileError("unable to translate macro: undefined identifier `__builtin_va_end`"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stdarg.h:35:9 +pub const va_arg = @compileError("unable to translate C expr: unexpected token 'an identifier'"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stdarg.h:36:9 +pub const __va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stdarg.h:41:9 +pub const va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stdarg.h:46:9 +pub const __strong_alias = @compileError("unable to translate C expr: unexpected token '__asm__'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:53:9 +pub const __CONCAT1 = @compileError("unable to translate C expr: unexpected token '##'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:75:9 +pub const __STRING = @compileError("unable to translate C expr: unexpected token '#'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:79:9 +pub const __always_inline = @compileError("unable to translate macro: undefined identifier `__always_inline__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:86:9 +pub const __attribute_const__ = @compileError("unable to translate C expr: unexpected token '__attribute__'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:87:9 +pub const __attribute_pure__ = @compileError("unable to translate macro: undefined identifier `__pure__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:88:9 +pub const __dead = @compileError("unable to translate macro: undefined identifier `__noreturn__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:89:9 +pub const __noreturn = @compileError("unable to translate macro: undefined identifier `__noreturn__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:90:9 +pub const __mallocfunc = @compileError("unable to translate macro: undefined identifier `__malloc__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:91:9 +pub const __packed = @compileError("unable to translate macro: undefined identifier `__packed__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:92:9 +pub const __returns_twice = @compileError("unable to translate macro: undefined identifier `__returns_twice__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:93:9 +pub const __unused = @compileError("unable to translate macro: undefined identifier `__unused__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:94:9 +pub const __used = @compileError("unable to translate macro: undefined identifier `__used__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:95:9 +pub const __printflike = @compileError("unable to translate macro: undefined identifier `__format__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:97:9 +pub const __scanflike = @compileError("unable to translate macro: undefined identifier `__format__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:98:9 +pub const __strftimelike = @compileError("unable to translate macro: undefined identifier `__format__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:99:9 +pub const __wur = @compileError("unable to translate macro: undefined identifier `__warn_unused_result__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:132:9 +pub const __errorattr = @compileError("unable to translate macro: undefined identifier `unavailable`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:134:9 +pub const __warnattr = @compileError("unable to translate macro: undefined identifier `deprecated`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:135:9 +pub const __warnattr_real = @compileError("unable to translate macro: undefined identifier `deprecated`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:136:9 +pub const __enable_if = @compileError("unable to translate macro: undefined identifier `enable_if`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:137:9 +pub const __clang_error_if = @compileError("unable to translate macro: undefined identifier `diagnose_if`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:138:9 +pub const __clang_warning_if = @compileError("unable to translate macro: undefined identifier `diagnose_if`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:139:9 +pub const __warnattr_strict = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:148:11 +pub const __IDSTRING = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:156:9 +pub const __COPYRIGHT = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:157:9 +pub const __FBSDID = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:158:9 +pub const __RCSID = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:159:9 +pub const __SCCSID = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:160:9 +pub const __RENAME_IF_FILE_OFFSET64 = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:193:11 +pub const __RENAME_LDBL = @compileError("unable to translate C expr: unexpected token 'an identifier'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:215:9 +pub const __RENAME_LDBL_NO_GUARD_FOR_NDK = @compileError("unable to translate C expr: unexpected token 'an identifier'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:216:9 +pub const __RENAME_STAT64 = @compileError("unable to translate C expr: unexpected token 'an identifier'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:226:9 +pub const __pass_object_size_n = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:301:11 +pub const __bos_trivially_ge = @compileError("unable to translate C expr: unexpected token '>='"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:321:9 +pub const __bos_trivially_gt = @compileError("unable to translate C expr: unexpected token '>'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:322:9 +pub const __overloadable = @compileError("unable to translate macro: undefined identifier `overloadable`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:328:9 +pub const __diagnose_as_builtin = @compileError("unable to translate C expr: expected ')' instead got '...'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:330:9 +pub const __LIBC_HIDDEN__ = @compileError("unable to translate macro: undefined identifier `visibility`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:333:9 +pub const __LIBC32_LEGACY_PUBLIC__ = @compileError("unable to translate macro: undefined identifier `visibility`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:342:9 +pub const __RENAME = @compileError("unable to translate C expr: unexpected token '__asm__'"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:346:9 +pub const __size_mul_overflow = @compileError("unable to translate macro: undefined identifier `__builtin_umul_overflow`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/sys/cdefs.h:352:9 +pub const __BIONIC_AVAILABILITY = @compileError("unable to translate macro: undefined identifier `__availability__`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:57:9 +pub const __INTRODUCED_IN_NO_GUARD_FOR_NDK = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:58:9 +pub const __INTRODUCED_IN_X86_NO_GUARD_FOR_NDK = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:59:9 +pub const __INTRODUCED_IN = @compileError("unable to translate macro: undefined identifier `introduced`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:62:9 +pub const __DEPRECATED_IN = @compileError("unable to translate macro: undefined identifier `deprecated`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:63:9 +pub const __REMOVED_IN = @compileError("unable to translate macro: undefined identifier `obsoleted`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:64:9 +pub const __INTRODUCED_IN_32 = @compileError("unable to translate macro: undefined identifier `introduced`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:79:9 +pub const __INTRODUCED_IN_64 = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:80:9 +pub const __INTRODUCED_IN_ARM = @compileError("unable to translate C expr: unexpected token ''"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:90:9 +pub const __INTRODUCED_IN_X86 = @compileError("unable to translate macro: undefined identifier `introduced`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/android/versioning.h:91:9 +pub const offsetof = @compileError("unable to translate C expr: unexpected token 'an identifier'"); // C:\ProgramTools\zig-windows-x86_64-0.12.0-dev.1746+19af8aac8\lib\include/stddef.h:116:9 +pub const JNIEXPORT = @compileError("unable to translate macro: undefined identifier `visibility`"); // D:\Android\sdk\ndk\25.1.8937393\toolchains\llvm\prebuilt\windows-x86_64\sysroot\usr\include/jni.h:1105:9 +pub const __llvm__ = @as(c_int, 1); +pub const __clang__ = @as(c_int, 1); +pub const __clang_major__ = @as(c_int, 17); +pub const __clang_minor__ = @as(c_int, 0); +pub const __clang_patchlevel__ = @as(c_int, 3); +pub const __clang_version__ = "17.0.3 (https://github.com/ziglang/zig-bootstrap 1dc1fa6a122996fcd030cc956385e055289e09d9)"; +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 __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 17.0.3 (https://github.com/ziglang/zig-bootstrap 1dc1fa6a122996fcd030cc956385e055289e09d9)"; +pub const __OBJC_BOOL_IS_BOOL = @as(c_int, 0); +pub const __CONSTANT_CFSTRINGS__ = @as(c_int, 1); +pub const __SEH__ = @as(c_int, 1); +pub const __clang_literal_encoding__ = "UTF-8"; +pub const __clang_wide_literal_encoding__ = "UTF-16"; +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 __CHAR_BIT__ = @as(c_int, 8); +pub const __BOOL_WIDTH__ = @as(c_int, 8); +pub const __SHRT_WIDTH__ = @as(c_int, 16); +pub const __INT_WIDTH__ = @as(c_int, 32); +pub const __LONG_WIDTH__ = @as(c_int, 32); +pub const __LLONG_WIDTH__ = @as(c_int, 64); +pub const __BITINT_MAXWIDTH__ = 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__ = std.zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __LONG_MAX__ = @as(c_long, 2147483647); +pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __WCHAR_MAX__ = std.zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __WCHAR_WIDTH__ = @as(c_int, 16); +pub const __WINT_MAX__ = std.zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __WINT_WIDTH__ = @as(c_int, 16); +pub const __INTMAX_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __INTMAX_WIDTH__ = @as(c_int, 64); +pub const __SIZE_MAX__ = @as(c_ulonglong, 18446744073709551615); +pub const __SIZE_WIDTH__ = @as(c_int, 64); +pub const __UINTMAX_MAX__ = @as(c_ulonglong, 18446744073709551615); +pub const __UINTMAX_WIDTH__ = @as(c_int, 64); +pub const __PTRDIFF_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __PTRDIFF_WIDTH__ = @as(c_int, 64); +pub const __INTPTR_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __INTPTR_WIDTH__ = @as(c_int, 64); +pub const __UINTPTR_MAX__ = @as(c_ulonglong, 18446744073709551615); +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, 4); +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, 2); +pub const __SIZEOF_WINT_T__ = @as(c_int, 2); +pub const __SIZEOF_INT128__ = @as(c_int, 16); +pub const __INTMAX_TYPE__ = c_longlong; +pub const __INTMAX_FMTd__ = "lld"; +pub const __INTMAX_FMTi__ = "lli"; +pub const __UINTMAX_TYPE__ = c_ulonglong; +pub const __UINTMAX_FMTo__ = "llo"; +pub const __UINTMAX_FMTu__ = "llu"; +pub const __UINTMAX_FMTx__ = "llx"; +pub const __UINTMAX_FMTX__ = "llX"; +pub const __PTRDIFF_TYPE__ = c_longlong; +pub const __PTRDIFF_FMTd__ = "lld"; +pub const __PTRDIFF_FMTi__ = "lli"; +pub const __INTPTR_TYPE__ = c_longlong; +pub const __INTPTR_FMTd__ = "lld"; +pub const __INTPTR_FMTi__ = "lli"; +pub const __SIZE_TYPE__ = c_ulonglong; +pub const __SIZE_FMTo__ = "llo"; +pub const __SIZE_FMTu__ = "llu"; +pub const __SIZE_FMTx__ = "llx"; +pub const __SIZE_FMTX__ = "llX"; +pub const __WCHAR_TYPE__ = c_ushort; +pub const __WINT_TYPE__ = c_ushort; +pub const __SIG_ATOMIC_MAX__ = 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_ulonglong; +pub const __UINTPTR_FMTo__ = "llo"; +pub const __UINTPTR_FMTu__ = "llu"; +pub const __UINTPTR_FMTx__ = "llx"; +pub const __UINTPTR_FMTX__ = "llX"; +pub const __FLT16_DENORM_MIN__ = @as(f16, 5.9604644775390625e-8); +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_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_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_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 __WCHAR_UNSIGNED__ = @as(c_int, 1); +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 const __INT16_TYPE__ = c_short; +pub const __INT16_FMTd__ = "hd"; +pub const __INT16_FMTi__ = "hi"; +pub const __INT16_C_SUFFIX__ = ""; +pub const __INT32_TYPE__ = c_int; +pub const __INT32_FMTd__ = "d"; +pub const __INT32_FMTi__ = "i"; +pub const __INT32_C_SUFFIX__ = ""; +pub const __INT64_TYPE__ = c_longlong; +pub const __INT64_FMTd__ = "lld"; +pub const __INT64_FMTi__ = "lli"; +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 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 const __UINT16_MAX__ = 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_MAX__ = std.zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __INT32_MAX__ = std.zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __UINT64_TYPE__ = c_ulonglong; +pub const __UINT64_FMTo__ = "llo"; +pub const __UINT64_FMTu__ = "llu"; +pub const __UINT64_FMTx__ = "llx"; +pub const __UINT64_FMTX__ = "llX"; +pub const __UINT64_MAX__ = @as(c_ulonglong, 18446744073709551615); +pub const __INT64_MAX__ = @as(c_longlong, 9223372036854775807); +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__ = 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__ = 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__ = 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_longlong; +pub const __INT_LEAST64_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __INT_LEAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_LEAST64_FMTd__ = "lld"; +pub const __INT_LEAST64_FMTi__ = "lli"; +pub const __UINT_LEAST64_TYPE__ = c_ulonglong; +pub const __UINT_LEAST64_MAX__ = @as(c_ulonglong, 18446744073709551615); +pub const __UINT_LEAST64_FMTo__ = "llo"; +pub const __UINT_LEAST64_FMTu__ = "llu"; +pub const __UINT_LEAST64_FMTx__ = "llx"; +pub const __UINT_LEAST64_FMTX__ = "llX"; +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__ = 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__ = 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__ = 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_longlong; +pub const __INT_FAST64_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __INT_FAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_FAST64_FMTd__ = "lld"; +pub const __INT_FAST64_FMTi__ = "lli"; +pub const __UINT_FAST64_TYPE__ = c_ulonglong; +pub const __UINT_FAST64_MAX__ = @as(c_ulonglong, 18446744073709551615); +pub const __UINT_FAST64_FMTo__ = "llo"; +pub const __UINT_FAST64_FMTu__ = "llu"; +pub const __UINT_FAST64_FMTx__ = "llx"; +pub const __UINT_FAST64_FMTX__ = "llX"; +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 __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 __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 __k8 = @as(c_int, 1); +pub const __k8__ = @as(c_int, 1); +pub const __tune_k8__ = @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 __PCLMUL__ = @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 __MOVBE__ = @as(c_int, 1); +pub const __FMA__ = @as(c_int, 1); +pub const __F16C__ = @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 __CLFLUSHOPT__ = @as(c_int, 1); +pub const __SGX__ = @as(c_int, 1); +pub const __INVPCID__ = @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 _WIN32 = @as(c_int, 1); +pub const _WIN64 = @as(c_int, 1); +pub const WIN32 = @as(c_int, 1); +pub const __WIN32 = @as(c_int, 1); +pub const __WIN32__ = @as(c_int, 1); +pub const WINNT = @as(c_int, 1); +pub const __WINNT = @as(c_int, 1); +pub const __WINNT__ = @as(c_int, 1); +pub const WIN64 = @as(c_int, 1); +pub const __WIN64 = @as(c_int, 1); +pub const __WIN64__ = @as(c_int, 1); +pub const __MINGW64__ = @as(c_int, 1); +pub const __MSVCRT__ = @as(c_int, 1); +pub const __MINGW32__ = @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 _WIN32_WINNT = @as(c_int, 0x0a00); +pub const _DEBUG = @as(c_int, 1); +pub const OPENSL_ES_ANDROID_H_ = ""; +pub const OPENSL_ES_H_ = ""; +pub const _OPENSLES_PLATFORM_H_ = ""; +pub const SL_API = ""; +pub const SLAPIENTRY = ""; +pub const _KHRONOS_KEYS_ = ""; +pub const KHRONOS_TITLE = "KhronosTitle"; +pub const KHRONOS_ALBUM = "KhronosAlbum"; +pub const KHRONOS_TRACK_NUMBER = "KhronosTrackNumber"; +pub const KHRONOS_ARTIST = "KhronosArtist"; +pub const KHRONOS_GENRE = "KhronosGenre"; +pub const KHRONOS_YEAR = "KhronosYear"; +pub const KHRONOS_COMMENT = "KhronosComment"; +pub const KHRONOS_ARTIST_URL = "KhronosArtistURL"; +pub const KHRONOS_CONTENT_URL = "KhronosContentURL"; +pub const KHRONOS_RATING = "KhronosRating"; +pub const KHRONOS_ALBUM_ART = "KhronosAlbumArt"; +pub const KHRONOS_COPYRIGHT = "KhronosCopyright"; +pub const SL_BOOLEAN_FALSE = std.zig.c_translation.cast(SLboolean, @as(c_int, 0x00000000)); +pub const SL_BOOLEAN_TRUE = std.zig.c_translation.cast(SLboolean, @as(c_int, 0x00000001)); +pub const SL_MILLIBEL_MAX = std.zig.c_translation.cast(SLmillibel, @as(c_int, 0x7FFF)); +pub const SL_MILLIBEL_MIN = std.zig.c_translation.cast(SLmillibel, -SL_MILLIBEL_MAX - @as(c_int, 1)); +pub const SL_MILLIHERTZ_MAX = std.zig.c_translation.cast(SLmilliHertz, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFF, .hex)); +pub const SL_MILLIMETER_MAX = std.zig.c_translation.cast(SLmillimeter, std.zig.c_translation.promoteIntLiteral(c_int, 0x7FFFFFFF, .hex)); +pub const SL_OBJECTID_ENGINE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001001)); +pub const SL_OBJECTID_LEDDEVICE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001002)); +pub const SL_OBJECTID_VIBRADEVICE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001003)); +pub const SL_OBJECTID_AUDIOPLAYER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001004)); +pub const SL_OBJECTID_AUDIORECORDER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001005)); +pub const SL_OBJECTID_MIDIPLAYER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001006)); +pub const SL_OBJECTID_LISTENER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001007)); +pub const SL_OBJECTID_3DGROUP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001008)); +pub const SL_OBJECTID_OUTPUTMIX = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001009)); +pub const SL_OBJECTID_METADATAEXTRACTOR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000100A)); +pub const SL_PROFILES_PHONE = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0001)); +pub const SL_PROFILES_MUSIC = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0002)); +pub const SL_PROFILES_GAME = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0004)); +pub const SL_VOICETYPE_2D_AUDIO = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0001)); +pub const SL_VOICETYPE_MIDI = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0002)); +pub const SL_VOICETYPE_3D_AUDIO = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0004)); +pub const SL_VOICETYPE_3D_MIDIOUTPUT = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0008)); +pub const SL_PRIORITY_LOWEST = std.zig.c_translation.cast(SLint32, -std.zig.c_translation.promoteIntLiteral(c_int, 0x7FFFFFFF, .hex) - @as(c_int, 1)); +pub const SL_PRIORITY_VERYLOW = std.zig.c_translation.cast(SLint32, -std.zig.c_translation.promoteIntLiteral(c_int, 0x60000000, .hex)); +pub const SL_PRIORITY_LOW = std.zig.c_translation.cast(SLint32, -std.zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hex)); +pub const SL_PRIORITY_BELOWNORMAL = std.zig.c_translation.cast(SLint32, -std.zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hex)); +pub const SL_PRIORITY_NORMAL = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000000)); +pub const SL_PRIORITY_ABOVENORMAL = std.zig.c_translation.cast(SLint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hex)); +pub const SL_PRIORITY_HIGH = std.zig.c_translation.cast(SLint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hex)); +pub const SL_PRIORITY_VERYHIGH = std.zig.c_translation.cast(SLint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x60000000, .hex)); +pub const SL_PRIORITY_HIGHEST = std.zig.c_translation.cast(SLint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x7FFFFFFF, .hex)); +pub const SL_PCMSAMPLEFORMAT_FIXED_8 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0008)); +pub const SL_PCMSAMPLEFORMAT_FIXED_16 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0010)); +pub const SL_PCMSAMPLEFORMAT_FIXED_20 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0014)); +pub const SL_PCMSAMPLEFORMAT_FIXED_24 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0018)); +pub const SL_PCMSAMPLEFORMAT_FIXED_28 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x001C)); +pub const SL_PCMSAMPLEFORMAT_FIXED_32 = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0020)); +pub const SL_SAMPLINGRATE_8 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 8000000, .decimal)); +pub const SL_SAMPLINGRATE_11_025 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 11025000, .decimal)); +pub const SL_SAMPLINGRATE_12 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 12000000, .decimal)); +pub const SL_SAMPLINGRATE_16 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 16000000, .decimal)); +pub const SL_SAMPLINGRATE_22_05 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 22050000, .decimal)); +pub const SL_SAMPLINGRATE_24 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 24000000, .decimal)); +pub const SL_SAMPLINGRATE_32 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 32000000, .decimal)); +pub const SL_SAMPLINGRATE_44_1 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 44100000, .decimal)); +pub const SL_SAMPLINGRATE_48 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 48000000, .decimal)); +pub const SL_SAMPLINGRATE_64 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 64000000, .decimal)); +pub const SL_SAMPLINGRATE_88_2 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 88200000, .decimal)); +pub const SL_SAMPLINGRATE_96 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 96000000, .decimal)); +pub const SL_SAMPLINGRATE_192 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 192000000, .decimal)); +pub const SL_SPEAKER_FRONT_LEFT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_SPEAKER_FRONT_RIGHT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_SPEAKER_FRONT_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_SPEAKER_LOW_FREQUENCY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_SPEAKER_BACK_LEFT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_SPEAKER_BACK_RIGHT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000020)); +pub const SL_SPEAKER_FRONT_LEFT_OF_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000040)); +pub const SL_SPEAKER_FRONT_RIGHT_OF_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000080)); +pub const SL_SPEAKER_BACK_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000100)); +pub const SL_SPEAKER_SIDE_LEFT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000200)); +pub const SL_SPEAKER_SIDE_RIGHT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000400)); +pub const SL_SPEAKER_TOP_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000800)); +pub const SL_SPEAKER_TOP_FRONT_LEFT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00001000)); +pub const SL_SPEAKER_TOP_FRONT_CENTER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00002000)); +pub const SL_SPEAKER_TOP_FRONT_RIGHT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00004000)); +pub const SL_SPEAKER_TOP_BACK_LEFT = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x00008000, .hex)); +pub const SL_SPEAKER_TOP_BACK_CENTER = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x00010000, .hex)); +pub const SL_SPEAKER_TOP_BACK_RIGHT = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x00020000, .hex)); +pub const SL_RESULT_SUCCESS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_RESULT_PRECONDITIONS_VIOLATED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_RESULT_PARAMETER_INVALID = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_RESULT_MEMORY_FAILURE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_RESULT_RESOURCE_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_RESULT_RESOURCE_LOST = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_RESULT_IO_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_RESULT_BUFFER_INSUFFICIENT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_RESULT_CONTENT_CORRUPTED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_RESULT_CONTENT_UNSUPPORTED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000009)); +pub const SL_RESULT_CONTENT_NOT_FOUND = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000A)); +pub const SL_RESULT_PERMISSION_DENIED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000B)); +pub const SL_RESULT_FEATURE_UNSUPPORTED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000C)); +pub const SL_RESULT_INTERNAL_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000D)); +pub const SL_RESULT_UNKNOWN_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000E)); +pub const SL_RESULT_OPERATION_ABORTED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000F)); +pub const SL_RESULT_CONTROL_LOST = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_OBJECT_STATE_UNREALIZED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_OBJECT_STATE_REALIZED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_OBJECT_STATE_SUSPENDED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_OBJECT_EVENT_RUNTIME_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_OBJECT_EVENT_ASYNC_TERMINATION = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_OBJECT_EVENT_RESOURCES_LOST = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_OBJECT_EVENT_RESOURCES_AVAILABLE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_OBJECT_EVENT_ITF_CONTROL_TAKEN = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_OBJECT_EVENT_ITF_CONTROL_RETURNED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_OBJECT_EVENT_ITF_PARAMETERS_CHANGED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_DATALOCATOR_URI = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_DATALOCATOR_ADDRESS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_DATALOCATOR_IODEVICE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_DATALOCATOR_OUTPUTMIX = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_DATALOCATOR_RESERVED5 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_DATALOCATOR_BUFFERQUEUE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_DATALOCATOR_MIDIBUFFERQUEUE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_DATALOCATOR_RESERVED8 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_IODEVICE_AUDIOINPUT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_IODEVICE_LEDARRAY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_IODEVICE_VIBRA = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_IODEVICE_RESERVED4 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_IODEVICE_RESERVED5 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_DATAFORMAT_MIME = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_DATAFORMAT_PCM = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_DATAFORMAT_RESERVED3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_BYTEORDER_BIGENDIAN = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_BYTEORDER_LITTLEENDIAN = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_CONTAINERTYPE_UNSPECIFIED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_CONTAINERTYPE_RAW = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_CONTAINERTYPE_ASF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_CONTAINERTYPE_AVI = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_CONTAINERTYPE_BMP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_CONTAINERTYPE_JPG = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_CONTAINERTYPE_JPG2000 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_CONTAINERTYPE_M4A = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_CONTAINERTYPE_MP3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000009)); +pub const SL_CONTAINERTYPE_MP4 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000A)); +pub const SL_CONTAINERTYPE_MPEG_ES = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000B)); +pub const SL_CONTAINERTYPE_MPEG_PS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000C)); +pub const SL_CONTAINERTYPE_MPEG_TS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000D)); +pub const SL_CONTAINERTYPE_QT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000E)); +pub const SL_CONTAINERTYPE_WAV = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000F)); +pub const SL_CONTAINERTYPE_XMF_0 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_CONTAINERTYPE_XMF_1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000011)); +pub const SL_CONTAINERTYPE_XMF_2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000012)); +pub const SL_CONTAINERTYPE_XMF_3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000013)); +pub const SL_CONTAINERTYPE_XMF_GENERIC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000014)); +pub const SL_CONTAINERTYPE_AMR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000015)); +pub const SL_CONTAINERTYPE_AAC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000016)); +pub const SL_CONTAINERTYPE_3GPP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000017)); +pub const SL_CONTAINERTYPE_3GA = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000018)); +pub const SL_CONTAINERTYPE_RM = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000019)); +pub const SL_CONTAINERTYPE_DMF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001A)); +pub const SL_CONTAINERTYPE_SMF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001B)); +pub const SL_CONTAINERTYPE_MOBILE_DLS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001C)); +pub const SL_CONTAINERTYPE_OGG = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001D)); +pub const SL_DEFAULTDEVICEID_AUDIOINPUT = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFF, .hex)); +pub const SL_DEFAULTDEVICEID_AUDIOOUTPUT = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFE, .hex)); +pub const SL_DEFAULTDEVICEID_LED = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFD, .hex)); +pub const SL_DEFAULTDEVICEID_VIBRA = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFC, .hex)); +pub const SL_DEFAULTDEVICEID_RESERVED1 = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFB, .hex)); +pub const SL_DEVCONNECTION_INTEGRATED = std.zig.c_translation.cast(SLint16, @as(c_int, 0x0001)); +pub const SL_DEVCONNECTION_ATTACHED_WIRED = std.zig.c_translation.cast(SLint16, @as(c_int, 0x0100)); +pub const SL_DEVCONNECTION_ATTACHED_WIRELESS = std.zig.c_translation.cast(SLint16, @as(c_int, 0x0200)); +pub const SL_DEVCONNECTION_NETWORK = std.zig.c_translation.cast(SLint16, @as(c_int, 0x0400)); +pub const SL_DEVLOCATION_HANDSET = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0001)); +pub const SL_DEVLOCATION_HEADSET = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0002)); +pub const SL_DEVLOCATION_CARKIT = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0003)); +pub const SL_DEVLOCATION_DOCK = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0004)); +pub const SL_DEVLOCATION_REMOTE = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0005)); +pub const SL_DEVLOCATION_RESLTE = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0005)); +pub const SL_DEVSCOPE_UNKNOWN = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0001)); +pub const SL_DEVSCOPE_ENVIRONMENT = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0002)); +pub const SL_DEVSCOPE_USER = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0003)); +pub const SL_CHARACTERENCODING_UNKNOWN = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_CHARACTERENCODING_BINARY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_CHARACTERENCODING_ASCII = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_CHARACTERENCODING_BIG5 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_CHARACTERENCODING_CODEPAGE1252 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_CHARACTERENCODING_GB2312 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_CHARACTERENCODING_HZGB2312 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_CHARACTERENCODING_GB12345 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_CHARACTERENCODING_GB18030 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_CHARACTERENCODING_GBK = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000009)); +pub const SL_CHARACTERENCODING_IMAPUTF7 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000A)); +pub const SL_CHARACTERENCODING_ISO2022JP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000B)); +pub const SL_CHARACTERENCODING_ISO2022JP1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000B)); +pub const SL_CHARACTERENCODING_ISO88591 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000C)); +pub const SL_CHARACTERENCODING_ISO885910 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000D)); +pub const SL_CHARACTERENCODING_ISO885913 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000E)); +pub const SL_CHARACTERENCODING_ISO885914 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000F)); +pub const SL_CHARACTERENCODING_ISO885915 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_CHARACTERENCODING_ISO88592 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000011)); +pub const SL_CHARACTERENCODING_ISO88593 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000012)); +pub const SL_CHARACTERENCODING_ISO88594 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000013)); +pub const SL_CHARACTERENCODING_ISO88595 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000014)); +pub const SL_CHARACTERENCODING_ISO88596 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000015)); +pub const SL_CHARACTERENCODING_ISO88597 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000016)); +pub const SL_CHARACTERENCODING_ISO88598 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000017)); +pub const SL_CHARACTERENCODING_ISO88599 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000018)); +pub const SL_CHARACTERENCODING_ISOEUCJP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000019)); +pub const SL_CHARACTERENCODING_SHIFTJIS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001A)); +pub const SL_CHARACTERENCODING_SMS7BIT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001B)); +pub const SL_CHARACTERENCODING_UTF7 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001C)); +pub const SL_CHARACTERENCODING_UTF8 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001D)); +pub const SL_CHARACTERENCODING_JAVACONFORMANTUTF8 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001E)); +pub const SL_CHARACTERENCODING_UTF16BE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000001F)); +pub const SL_CHARACTERENCODING_UTF16LE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000020)); +pub const SL_METADATA_FILTER_KEY = std.zig.c_translation.cast(SLuint8, @as(c_int, 0x01)); +pub const SL_METADATA_FILTER_LANG = std.zig.c_translation.cast(SLuint8, @as(c_int, 0x02)); +pub const SL_METADATA_FILTER_ENCODING = std.zig.c_translation.cast(SLuint8, @as(c_int, 0x04)); +pub const SL_METADATATRAVERSALMODE_ALL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_METADATATRAVERSALMODE_NODE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_NODETYPE_UNSPECIFIED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_NODETYPE_AUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_NODETYPE_VIDEO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_NODETYPE_IMAGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_NODE_PARENT = std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFF, .hex); +pub const SL_PLAYSTATE_STOPPED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_PLAYSTATE_PAUSED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_PLAYSTATE_PLAYING = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_PLAYEVENT_HEADATEND = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_PLAYEVENT_HEADATMARKER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_PLAYEVENT_HEADATNEWPOS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_PLAYEVENT_HEADMOVING = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_PLAYEVENT_HEADSTALLED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_TIME_UNKNOWN = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFFFFFF, .hex)); +pub const SL_PREFETCHEVENT_STATUSCHANGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_PREFETCHEVENT_FILLLEVELCHANGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_PREFETCHSTATUS_UNDERFLOW = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_PREFETCHSTATUS_SUFFICIENTDATA = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_PREFETCHSTATUS_OVERFLOW = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_RATEPROP_RESERVED1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_RATEPROP_RESERVED2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_RATEPROP_SILENTAUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000100)); +pub const SL_RATEPROP_STAGGEREDAUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000200)); +pub const SL_RATEPROP_NOPITCHCORAUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000400)); +pub const SL_RATEPROP_PITCHCORAUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000800)); +pub const SL_SEEKMODE_FAST = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0001)); +pub const SL_SEEKMODE_ACCURATE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0002)); +pub const SL_RECORDSTATE_STOPPED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_RECORDSTATE_PAUSED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_RECORDSTATE_RECORDING = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_RECORDEVENT_HEADATLIMIT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_RECORDEVENT_HEADATMARKER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_RECORDEVENT_HEADATNEWPOS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_RECORDEVENT_HEADMOVING = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_RECORDEVENT_HEADSTALLED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000010)); +pub const SL_RECORDEVENT_BUFFER_INSUFFICIENT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000020)); +pub const SL_RECORDEVENT_BUFFER_FULL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000020)); +pub const SL_EQUALIZER_UNDEFINED = std.zig.c_translation.cast(SLuint16, std.zig.c_translation.promoteIntLiteral(c_int, 0xFFFF, .hex)); +pub const SL_REVERBPRESET_NONE = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0000)); +pub const SL_REVERBPRESET_SMALLROOM = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0001)); +pub const SL_REVERBPRESET_MEDIUMROOM = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0002)); +pub const SL_REVERBPRESET_LARGEROOM = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0003)); +pub const SL_REVERBPRESET_MEDIUMHALL = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0004)); +pub const SL_REVERBPRESET_LARGEHALL = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0005)); +pub const SL_REVERBPRESET_PLATE = std.zig.c_translation.cast(SLuint16, @as(c_int, 0x0006)); +pub const SL_ROLLOFFMODEL_EXPONENTIAL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_ROLLOFFMODEL_LINEAR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_DYNAMIC_ITF_EVENT_RUNTIME_ERROR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_DYNAMIC_ITF_EVENT_ASYNC_TERMINATION = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST_PERMANENTLY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_AVAILABLE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_MIDIMESSAGETYPE_NOTE_ON_OFF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_MIDIMESSAGETYPE_POLY_PRESSURE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_MIDIMESSAGETYPE_CONTROL_CHANGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_MIDIMESSAGETYPE_PROGRAM_CHANGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_MIDIMESSAGETYPE_CHANNEL_PRESSURE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_MIDIMESSAGETYPE_PITCH_BEND = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_MIDIMESSAGETYPE_SYSTEM_MESSAGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_RATECONTROLMODE_CONSTANTBITRATE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_RATECONTROLMODE_VARIABLEBITRATE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOCODEC_PCM = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOCODEC_MP3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOCODEC_AMR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOCODEC_AMRWB = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOCODEC_AMRWBPLUS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_AUDIOCODEC_AAC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_AUDIOCODEC_WMA = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_AUDIOCODEC_REAL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_AUDIOPROFILE_PCM = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOPROFILE_MPEG1_L3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOPROFILE_MPEG2_L3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOPROFILE_MPEG25_L3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOCHANMODE_MP3_MONO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOCHANMODE_MP3_STEREO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOCHANMODE_MP3_JOINTSTEREO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOCHANMODE_MP3_DUAL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOPROFILE_AMR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOSTREAMFORMAT_CONFORMANCE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOSTREAMFORMAT_IF1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOSTREAMFORMAT_IF2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOSTREAMFORMAT_FSF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOSTREAMFORMAT_RTPPAYLOAD = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_AUDIOSTREAMFORMAT_ITU = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_AUDIOPROFILE_AMRWB = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOPROFILE_AMRWBPLUS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOPROFILE_AAC_AAC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOMODE_AAC_MAIN = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOMODE_AAC_LC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOMODE_AAC_SSR = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOMODE_AAC_LTP = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOMODE_AAC_HE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_AUDIOMODE_AAC_SCALABLE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_AUDIOMODE_AAC_ERLC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_AUDIOMODE_AAC_LD = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_AUDIOMODE_AAC_HE_PS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000009)); +pub const SL_AUDIOMODE_AAC_HE_MPS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x0000000A)); +pub const SL_AUDIOSTREAMFORMAT_MP2ADTS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOSTREAMFORMAT_MP4ADTS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOSTREAMFORMAT_MP4LOAS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOSTREAMFORMAT_MP4LATM = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOSTREAMFORMAT_ADIF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_AUDIOSTREAMFORMAT_MP4FF = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_AUDIOSTREAMFORMAT_RAW = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_AUDIOPROFILE_WMA7 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOPROFILE_WMA8 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOPROFILE_WMA9 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOPROFILE_WMA10 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOMODE_WMA_LEVEL1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOMODE_WMA_LEVEL2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOMODE_WMA_LEVEL3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOMODE_WMA_LEVEL4 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_AUDIOMODE_WMAPRO_LEVELM0 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_AUDIOMODE_WMAPRO_LEVELM1 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000006)); +pub const SL_AUDIOMODE_WMAPRO_LEVELM2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000007)); +pub const SL_AUDIOMODE_WMAPRO_LEVELM3 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000008)); +pub const SL_AUDIOPROFILE_REALAUDIO = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOMODE_REALAUDIO_G2 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_AUDIOMODE_REALAUDIO_8 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_AUDIOMODE_REALAUDIO_10 = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_AUDIOMODE_REALAUDIO_SURROUND = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_ENGINEOPTION_THREADSAFE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_ENGINEOPTION_LOSSOFCONTROL = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const OPENSL_ES_ANDROIDCONFIGURATION_H_ = ""; +pub const SL_ANDROID_RECORDING_PRESET_NONE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_ANDROID_RECORDING_PRESET_GENERIC = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_ANDROID_RECORDING_PRESET_CAMCORDER = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_ANDROID_RECORDING_PRESET_UNPROCESSED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000005)); +pub const SL_ANDROID_STREAM_VOICE = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000000)); +pub const SL_ANDROID_STREAM_SYSTEM = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000001)); +pub const SL_ANDROID_STREAM_RING = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000002)); +pub const SL_ANDROID_STREAM_MEDIA = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000003)); +pub const SL_ANDROID_STREAM_ALARM = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000004)); +pub const SL_ANDROID_STREAM_NOTIFICATION = std.zig.c_translation.cast(SLint32, @as(c_int, 0x00000005)); +pub const SL_ANDROID_PERFORMANCE_NONE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_ANDROID_PERFORMANCE_LATENCY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_ANDROID_PERFORMANCE_LATENCY_EFFECTS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_ANDROID_PERFORMANCE_POWER_SAVING = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const OPENSL_ES_ANDROIDMETADATA_H_ = ""; +pub const ANDROID_KEY_PCMFORMAT_NUMCHANNELS = "AndroidPcmFormatNumChannels"; +pub const ANDROID_KEY_PCMFORMAT_SAMPLERATE = "AndroidPcmFormatSampleRate"; +pub const ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE = "AndroidPcmFormatBitsPerSample"; +pub const ANDROID_KEY_PCMFORMAT_CONTAINERSIZE = "AndroidPcmFormatContainerSize"; +pub const ANDROID_KEY_PCMFORMAT_CHANNELMASK = "AndroidPcmFormatChannelMask"; +pub const ANDROID_KEY_PCMFORMAT_ENDIANNESS = "AndroidPcmFormatEndianness"; +pub const __GNUC_VA_LIST = ""; +pub const __STDARG_H = ""; +pub const _VA_LIST = ""; +pub const _STDINT_H = ""; +pub const __BIONIC__ = @as(c_int, 1); +pub const __BEGIN_DECLS = ""; +pub const __END_DECLS = ""; +pub inline fn __BIONIC_CAST(_k: anytype, _t: anytype, _v: anytype) @TypeOf(_t(_v)) { + _ = &_k; + _ = &_t; + _ = &_v; + return _t(_v); +} +pub inline fn __BIONIC_ALIGN(__value: anytype, __alignment: anytype) @TypeOf(((__value + __alignment) - @as(c_int, 1)) & ~(__alignment - @as(c_int, 1))) { + _ = &__value; + _ = &__alignment; + return ((__value + __alignment) - @as(c_int, 1)) & ~(__alignment - @as(c_int, 1)); +} +pub inline fn __P(protos: anytype) @TypeOf(protos) { + _ = &protos; + return protos; +} +pub inline fn __CONCAT(x: anytype, y: anytype) @TypeOf(__CONCAT1(x, y)) { + _ = &x; + _ = &y; + return __CONCAT1(x, y); +} +pub inline fn ___CONCAT(x: anytype, y: anytype) @TypeOf(__CONCAT(x, y)) { + _ = &x; + _ = &y; + return __CONCAT(x, y); +} +pub inline fn ___STRING(x: anytype) @TypeOf(__STRING(x)) { + _ = &x; + return __STRING(x); +} +pub inline fn __predict_true(exp: anytype) @TypeOf(__builtin_expect(exp != @as(c_int, 0), @as(c_int, 1))) { + _ = &exp; + return __builtin_expect(exp != @as(c_int, 0), @as(c_int, 1)); +} +pub inline fn __predict_false(exp: anytype) @TypeOf(__builtin_expect(exp != @as(c_int, 0), @as(c_int, 0))) { + _ = &exp; + return __builtin_expect(exp != @as(c_int, 0), @as(c_int, 0)); +} +pub const __WORDSIZE = @as(c_int, 32); +pub const __BIONIC_FORTIFY_UNKNOWN_SIZE = std.zig.c_translation.cast(usize, -@as(c_int, 1)); +pub const __bos_level = @as(c_int, 0); +pub inline fn __bosn(s: anytype, n: anytype) @TypeOf(__builtin_object_size(s, n)) { + _ = &s; + _ = &n; + return __builtin_object_size(s, n); +} +pub inline fn __bos(s: anytype) @TypeOf(__bosn(s, __bos_level)) { + _ = &s; + return __bosn(s, __bos_level); +} +pub const __pass_object_size = __pass_object_size_n(__bos_level); +pub const __pass_object_size0 = __pass_object_size_n(@as(c_int, 0)); +pub inline fn __bos_unevaluated_lt(bos_val: anytype, val: anytype) @TypeOf((bos_val != __BIONIC_FORTIFY_UNKNOWN_SIZE) and (bos_val < val)) { + _ = &bos_val; + _ = &val; + return (bos_val != __BIONIC_FORTIFY_UNKNOWN_SIZE) and (bos_val < val); +} +pub inline fn __bos_unevaluated_le(bos_val: anytype, val: anytype) @TypeOf((bos_val != __BIONIC_FORTIFY_UNKNOWN_SIZE) and (bos_val <= val)) { + _ = &bos_val; + _ = &val; + return (bos_val != __BIONIC_FORTIFY_UNKNOWN_SIZE) and (bos_val <= val); +} +pub inline fn __bos_dynamic_check_impl_and(bos_val: anytype, op: anytype, index: anytype, cond: anytype) @TypeOf((bos_val == __BIONIC_FORTIFY_UNKNOWN_SIZE) or (((__builtin_constant_p(index) != 0) and ((bos_val ++ op ++ index) != 0)) and (cond != 0))) { + _ = &bos_val; + _ = &op; + _ = &index; + _ = &cond; + return (bos_val == __BIONIC_FORTIFY_UNKNOWN_SIZE) or (((__builtin_constant_p(index) != 0) and ((bos_val ++ op ++ index) != 0)) and (cond != 0)); +} +pub inline fn __bos_dynamic_check_impl(bos_val: anytype, op: anytype, index: anytype) @TypeOf(__bos_dynamic_check_impl_and(bos_val, op, index, @as(c_int, 1))) { + _ = &bos_val; + _ = &op; + _ = &index; + return __bos_dynamic_check_impl_and(bos_val, op, index, @as(c_int, 1)); +} +pub inline fn __unsafe_check_mul_overflow(x: anytype, y: anytype) @TypeOf((__SIZE_TYPE__ - std.zig.c_translation.MacroArithmetic.div(@as(c_int, 1), x)) < y) { + _ = &x; + _ = &y; + return (__SIZE_TYPE__ - std.zig.c_translation.MacroArithmetic.div(@as(c_int, 1), x)) < y; +} +pub const __VERSIONER_NO_GUARD = ""; +pub const __VERSIONER_FORTIFY_INLINE = ""; +pub const __ANDROID_API_FUTURE__ = @as(c_int, 10000); +pub const __ANDROID_API__ = __ANDROID_API_FUTURE__; +pub const __ANDROID_API_G__ = @as(c_int, 9); +pub const __ANDROID_API_I__ = @as(c_int, 14); +pub const __ANDROID_API_J__ = @as(c_int, 16); +pub const __ANDROID_API_J_MR1__ = @as(c_int, 17); +pub const __ANDROID_API_J_MR2__ = @as(c_int, 18); +pub const __ANDROID_API_K__ = @as(c_int, 19); +pub const __ANDROID_API_L__ = @as(c_int, 21); +pub const __ANDROID_API_L_MR1__ = @as(c_int, 22); +pub const __ANDROID_API_M__ = @as(c_int, 23); +pub const __ANDROID_API_N__ = @as(c_int, 24); +pub const __ANDROID_API_N_MR1__ = @as(c_int, 25); +pub const __ANDROID_API_O__ = @as(c_int, 26); +pub const __ANDROID_API_O_MR1__ = @as(c_int, 27); +pub const __ANDROID_API_P__ = @as(c_int, 28); +pub const __ANDROID_API_Q__ = @as(c_int, 29); +pub const __ANDROID_API_R__ = @as(c_int, 30); +pub const __ANDROID_API_S__ = @as(c_int, 31); +pub const __ANDROID_API_T__ = @as(c_int, 33); +pub const __ANDROID_API_U__ = @as(c_int, 34); +pub const __ANDROID_NDK__ = @as(c_int, 1); +pub const __NDK_MAJOR__ = @as(c_int, 25); +pub const __NDK_MINOR__ = @as(c_int, 1); +pub const __NDK_BETA__ = @as(c_int, 0); +pub const __NDK_BUILD__ = std.zig.c_translation.promoteIntLiteral(c_int, 8937393, .decimal); +pub const __NDK_CANARY__ = @as(c_int, 0); +pub const WCHAR_MAX = __WCHAR_MAX__; +pub const WCHAR_MIN = '\x00'; +pub const __STDDEF_H = ""; +pub const __need_ptrdiff_t = ""; +pub const __need_size_t = ""; +pub const __need_wchar_t = ""; +pub const __need_NULL = ""; +pub const __need_STDDEF_H_misc = ""; +pub const _PTRDIFF_T = ""; +pub const _SIZE_T = ""; +pub const _WCHAR_T = ""; +pub const NULL = std.zig.c_translation.cast(?*anyopaque, @as(c_int, 0)); +pub const __CLANG_MAX_ALIGN_T_DEFINED = ""; +pub const __BIT_TYPES_DEFINED__ = ""; +pub inline fn INT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT_LEAST8_C(c: anytype) @TypeOf(INT8_C(c)) { + _ = &c; + return INT8_C(c); +} +pub inline fn INT_FAST8_C(c: anytype) @TypeOf(INT8_C(c)) { + _ = &c; + return INT8_C(c); +} +pub inline fn UINT8_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn UINT_LEAST8_C(c: anytype) @TypeOf(UINT8_C(c)) { + _ = &c; + return UINT8_C(c); +} +pub inline fn UINT_FAST8_C(c: anytype) @TypeOf(UINT8_C(c)) { + _ = &c; + return UINT8_C(c); +} +pub inline fn INT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT_LEAST16_C(c: anytype) @TypeOf(INT16_C(c)) { + _ = &c; + return INT16_C(c); +} +pub inline fn INT_FAST16_C(c: anytype) @TypeOf(INT32_C(c)) { + _ = &c; + return INT32_C(c); +} +pub inline fn UINT16_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn UINT_LEAST16_C(c: anytype) @TypeOf(UINT16_C(c)) { + _ = &c; + return UINT16_C(c); +} +pub inline fn UINT_FAST16_C(c: anytype) @TypeOf(UINT32_C(c)) { + _ = &c; + return UINT32_C(c); +} +pub inline fn INT32_C(c: anytype) @TypeOf(c) { + _ = &c; + return c; +} +pub inline fn INT_LEAST32_C(c: anytype) @TypeOf(INT32_C(c)) { + _ = &c; + return INT32_C(c); +} +pub inline fn INT_FAST32_C(c: anytype) @TypeOf(INT32_C(c)) { + _ = &c; + return INT32_C(c); +} +pub const UINT32_C = std.zig.c_translation.Macros.U_SUFFIX; +pub inline fn UINT_LEAST32_C(c: anytype) @TypeOf(UINT32_C(c)) { + _ = &c; + return UINT32_C(c); +} +pub inline fn UINT_FAST32_C(c: anytype) @TypeOf(UINT32_C(c)) { + _ = &c; + return UINT32_C(c); +} +pub inline fn INT_LEAST64_C(c: anytype) @TypeOf(INT64_C(c)) { + _ = &c; + return INT64_C(c); +} +pub inline fn INT_FAST64_C(c: anytype) @TypeOf(INT64_C(c)) { + _ = &c; + return INT64_C(c); +} +pub inline fn UINT_LEAST64_C(c: anytype) @TypeOf(UINT64_C(c)) { + _ = &c; + return UINT64_C(c); +} +pub inline fn UINT_FAST64_C(c: anytype) @TypeOf(UINT64_C(c)) { + _ = &c; + return UINT64_C(c); +} +pub inline fn INTMAX_C(c: anytype) @TypeOf(INT64_C(c)) { + _ = &c; + return INT64_C(c); +} +pub inline fn UINTMAX_C(c: anytype) @TypeOf(UINT64_C(c)) { + _ = &c; + return UINT64_C(c); +} +pub const INT64_C = std.zig.c_translation.Macros.LL_SUFFIX; +pub const UINT64_C = std.zig.c_translation.Macros.ULL_SUFFIX; +pub inline fn INTPTR_C(c: anytype) @TypeOf(INT32_C(c)) { + _ = &c; + return INT32_C(c); +} +pub inline fn UINTPTR_C(c: anytype) @TypeOf(UINT32_C(c)) { + _ = &c; + return UINT32_C(c); +} +pub inline fn PTRDIFF_C(c: anytype) @TypeOf(INT32_C(c)) { + _ = &c; + return INT32_C(c); +} +pub const INT8_MIN = -@as(c_int, 128); +pub const INT8_MAX = @as(c_int, 127); +pub const INT_LEAST8_MIN = INT8_MIN; +pub const INT_LEAST8_MAX = INT8_MAX; +pub const INT_FAST8_MIN = INT8_MIN; +pub const INT_FAST8_MAX = INT8_MAX; +pub const UINT8_MAX = @as(c_int, 255); +pub const UINT_LEAST8_MAX = UINT8_MAX; +pub const UINT_FAST8_MAX = UINT8_MAX; +pub const INT16_MIN = -std.zig.c_translation.promoteIntLiteral(c_int, 32768, .decimal); +pub const INT16_MAX = @as(c_int, 32767); +pub const INT_LEAST16_MIN = INT16_MIN; +pub const INT_LEAST16_MAX = INT16_MAX; +pub const INT_FAST16_MIN = INT32_MIN; +pub const INT_FAST16_MAX = INT32_MAX; +pub const UINT16_MAX = std.zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT_LEAST16_MAX = UINT16_MAX; +pub const UINT_FAST16_MAX = UINT32_MAX; +pub const INT32_MIN = -std.zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT32_MAX = std.zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT_LEAST32_MIN = INT32_MIN; +pub const INT_LEAST32_MAX = INT32_MAX; +pub const INT_FAST32_MIN = INT32_MIN; +pub const INT_FAST32_MAX = INT32_MAX; +pub const UINT32_MAX = std.zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT_LEAST32_MAX = UINT32_MAX; +pub const UINT_FAST32_MAX = UINT32_MAX; +pub const INT64_MIN = INT64_C(-std.zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT64_MAX = INT64_C(std.zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const INT_LEAST64_MIN = INT64_MIN; +pub const INT_LEAST64_MAX = INT64_MAX; +pub const INT_FAST64_MIN = INT64_MIN; +pub const INT_FAST64_MAX = INT64_MAX; +pub const UINT64_MAX = UINT64_C(std.zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const UINT_LEAST64_MAX = UINT64_MAX; +pub const UINT_FAST64_MAX = UINT64_MAX; +pub const INTMAX_MIN = INT64_MIN; +pub const INTMAX_MAX = INT64_MAX; +pub const UINTMAX_MAX = UINT64_MAX; +pub const SIG_ATOMIC_MAX = INT32_MAX; +pub const SIG_ATOMIC_MIN = INT32_MIN; +pub const WINT_MAX = UINT32_MAX; +pub const WINT_MIN = @as(c_int, 0); +pub const INTPTR_MIN = INT32_MIN; +pub const INTPTR_MAX = INT32_MAX; +pub const UINTPTR_MAX = UINT32_MAX; +pub const PTRDIFF_MIN = INT32_MIN; +pub const PTRDIFF_MAX = INT32_MAX; +pub const SIZE_MAX = UINT32_MAX; +pub const JNIIMPORT = ""; +pub const JNICALL = ""; +pub const JNI_FALSE = @as(c_int, 0); +pub const JNI_TRUE = @as(c_int, 1); +pub const JNI_VERSION_1_1 = std.zig.c_translation.promoteIntLiteral(c_int, 0x00010001, .hex); +pub const JNI_VERSION_1_2 = std.zig.c_translation.promoteIntLiteral(c_int, 0x00010002, .hex); +pub const JNI_VERSION_1_4 = std.zig.c_translation.promoteIntLiteral(c_int, 0x00010004, .hex); +pub const JNI_VERSION_1_6 = std.zig.c_translation.promoteIntLiteral(c_int, 0x00010006, .hex); +pub const JNI_OK = @as(c_int, 0); +pub const JNI_ERR = -@as(c_int, 1); +pub const JNI_EDETACHED = -@as(c_int, 2); +pub const JNI_EVERSION = -@as(c_int, 3); +pub const JNI_ENOMEM = -@as(c_int, 4); +pub const JNI_EEXIST = -@as(c_int, 5); +pub const JNI_EINVAL = -@as(c_int, 6); +pub const JNI_COMMIT = @as(c_int, 1); +pub const JNI_ABORT = @as(c_int, 2); +pub const SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_ANDROID_PCM_REPRESENTATION_FLOAT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_ANDROID_DATAFORMAT_PCM_EX = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_ANDROID_SPEAKER_NON_POSITIONAL = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hex)); +pub inline fn SL_ANDROID_MAKE_INDEXED_CHANNEL_MASK(bitfield: anytype) @TypeOf(bitfield | SL_ANDROID_SPEAKER_NON_POSITIONAL) { + _ = &bitfield; + return bitfield | SL_ANDROID_SPEAKER_NON_POSITIONAL; +} +pub const SL_ANDROID_SPEAKER_USE_DEFAULT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0)); +pub const SL_ANDROID_JAVA_PROXY_ROUTING = @as(c_int, 0x0001); +pub const SL_ANDROID_ITEMKEY_NONE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_ANDROID_ITEMKEY_EOS = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_ANDROID_ITEMKEY_DISCONTINUITY = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000002)); +pub const SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000003)); +pub const SL_ANDROID_ITEMKEY_FORMAT_CHANGE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000004)); +pub const SL_ANDROIDBUFFERQUEUEEVENT_NONE = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000000)); +pub const SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED = std.zig.c_translation.cast(SLuint32, @as(c_int, 0x00000001)); +pub const SL_DATALOCATOR_ANDROIDFD = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x800007BC, .hex)); +pub const SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE = std.zig.c_translation.cast(SLAint64, std.zig.c_translation.promoteIntLiteral(c_longlong, 0xFFFFFFFFFFFFFFFF, .hex)); +pub const SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x800007BD, .hex)); +pub const SL_DATALOCATOR_ANDROIDBUFFERQUEUE = std.zig.c_translation.cast(SLuint32, std.zig.c_translation.promoteIntLiteral(c_int, 0x800007BE, .hex)); +pub const SL_ANDROID_MIME_AACADTS = std.zig.c_translation.cast([*c]SLchar, "audio/vnd.android.aac-adts"); +pub const SLInterfaceID_ = struct_SLInterfaceID_; +pub const SLObjectItf_ = struct_SLObjectItf_; +pub const SLDataLocator_URI_ = struct_SLDataLocator_URI_; +pub const SLDataLocator_Address_ = struct_SLDataLocator_Address_; +pub const SLDataLocator_IODevice_ = struct_SLDataLocator_IODevice_; +pub const SLDataFormat_MIME_ = struct_SLDataFormat_MIME_; +pub const SLDataFormat_PCM_ = struct_SLDataFormat_PCM_; +pub const SLDataSource_ = struct_SLDataSource_; +pub const SLDataSink_ = struct_SLDataSink_; +pub const SLAudioInputDescriptor_ = struct_SLAudioInputDescriptor_; +pub const SLAudioOutputDescriptor_ = struct_SLAudioOutputDescriptor_; +pub const SLAudioIODeviceCapabilitiesItf_ = struct_SLAudioIODeviceCapabilitiesItf_; +pub const SLLEDDescriptor_ = struct_SLLEDDescriptor_; +pub const SLHSL_ = struct_SLHSL_; +pub const SLLEDArrayItf_ = struct_SLLEDArrayItf_; +pub const SLVibraDescriptor_ = struct_SLVibraDescriptor_; +pub const SLVibraItf_ = struct_SLVibraItf_; +pub const SLMetadataInfo_ = struct_SLMetadataInfo_; +pub const SLMetadataExtractionItf_ = struct_SLMetadataExtractionItf_; +pub const SLMetadataTraversalItf_ = struct_SLMetadataTraversalItf_; +pub const SLDynamicSourceItf_ = struct_SLDynamicSourceItf_; +pub const SLOutputMixItf_ = struct_SLOutputMixItf_; +pub const SLPlayItf_ = struct_SLPlayItf_; +pub const SLPrefetchStatusItf_ = struct_SLPrefetchStatusItf_; +pub const SLPlaybackRateItf_ = struct_SLPlaybackRateItf_; +pub const SLSeekItf_ = struct_SLSeekItf_; +pub const SLRecordItf_ = struct_SLRecordItf_; +pub const SLEqualizerItf_ = struct_SLEqualizerItf_; +pub const SLVolumeItf_ = struct_SLVolumeItf_; +pub const SLDeviceVolumeItf_ = struct_SLDeviceVolumeItf_; +pub const SLBufferQueueState_ = struct_SLBufferQueueState_; +pub const SLBufferQueueItf_ = struct_SLBufferQueueItf_; +pub const SLPresetReverbItf_ = struct_SLPresetReverbItf_; +pub const SLEnvironmentalReverbSettings_ = struct_SLEnvironmentalReverbSettings_; +pub const SLEnvironmentalReverbItf_ = struct_SLEnvironmentalReverbItf_; +pub const SLEffectSendItf_ = struct_SLEffectSendItf_; +pub const SL3DGroupingItf_ = struct_SL3DGroupingItf_; +pub const SL3DCommitItf_ = struct_SL3DCommitItf_; +pub const SLVec3D_ = struct_SLVec3D_; +pub const SL3DLocationItf_ = struct_SL3DLocationItf_; +pub const SL3DDopplerItf_ = struct_SL3DDopplerItf_; +pub const SL3DSourceItf_ = struct_SL3DSourceItf_; +pub const SL3DMacroscopicItf_ = struct_SL3DMacroscopicItf_; +pub const SLMuteSoloItf_ = struct_SLMuteSoloItf_; +pub const SLDynamicInterfaceManagementItf_ = struct_SLDynamicInterfaceManagementItf_; +pub const SLMIDIMessageItf_ = struct_SLMIDIMessageItf_; +pub const SLMIDIMuteSoloItf_ = struct_SLMIDIMuteSoloItf_; +pub const SLMIDITempoItf_ = struct_SLMIDITempoItf_; +pub const SLMIDITimeItf_ = struct_SLMIDITimeItf_; +pub const SLAudioCodecDescriptor_ = struct_SLAudioCodecDescriptor_; +pub const SLAudioCodecProfileMode_ = struct_SLAudioCodecProfileMode_; +pub const SLAudioDecoderCapabilitiesItf_ = struct_SLAudioDecoderCapabilitiesItf_; +pub const SLAudioEncoderSettings_ = struct_SLAudioEncoderSettings_; +pub const SLAudioEncoderCapabilitiesItf_ = struct_SLAudioEncoderCapabilitiesItf_; +pub const SLAudioEncoderItf_ = struct_SLAudioEncoderItf_; +pub const SLBassBoostItf_ = struct_SLBassBoostItf_; +pub const SLPitchItf_ = struct_SLPitchItf_; +pub const SLRatePitchItf_ = struct_SLRatePitchItf_; +pub const SLVirtualizerItf_ = struct_SLVirtualizerItf_; +pub const SLVisualizationItf_ = struct_SLVisualizationItf_; +pub const SLEngineItf_ = struct_SLEngineItf_; +pub const SLEngineCapabilitiesItf_ = struct_SLEngineCapabilitiesItf_; +pub const SLThreadSyncItf_ = struct_SLThreadSyncItf_; +pub const SLEngineOption_ = struct_SLEngineOption_; +pub const _jfieldID = struct__jfieldID; +pub const _jmethodID = struct__jmethodID; +pub const JNINativeInterface = struct_JNINativeInterface; +pub const JNIInvokeInterface = struct_JNIInvokeInterface; +pub const _JNIEnv = struct__JNIEnv; +pub const _JavaVM = struct__JavaVM; +pub const SLAndroidDataFormat_PCM_EX_ = struct_SLAndroidDataFormat_PCM_EX_; +pub const SLAndroidEffectItf_ = struct_SLAndroidEffectItf_; +pub const SLAndroidEffectSendItf_ = struct_SLAndroidEffectSendItf_; +pub const SLAndroidEffectCapabilitiesItf_ = struct_SLAndroidEffectCapabilitiesItf_; +pub const SLAndroidConfigurationItf_ = struct_SLAndroidConfigurationItf_; +pub const SLAndroidSimpleBufferQueueState_ = struct_SLAndroidSimpleBufferQueueState_; +pub const SLAndroidSimpleBufferQueueItf_ = struct_SLAndroidSimpleBufferQueueItf_; +pub const SLAndroidBufferItem_ = struct_SLAndroidBufferItem_; +pub const SLAndroidBufferQueueState_ = struct_SLAndroidBufferQueueState_; +pub const SLAndroidBufferQueueItf_ = struct_SLAndroidBufferQueueItf_; +pub const SLDataLocator_AndroidFD_ = struct_SLDataLocator_AndroidFD_; +pub const SLDataLocator_AndroidBufferQueue_ = struct_SLDataLocator_AndroidBufferQueue_; +pub const SLAndroidAcousticEchoCancellationItf_ = struct_SLAndroidAcousticEchoCancellationItf_; +pub const SLAndroidAutomaticGainControlItf_ = struct_SLAndroidAutomaticGainControlItf_; +pub const SLAndroidNoiseSuppressionItf_ = struct_SLAndroidNoiseSuppressionItf_; diff --git a/src/c.zig b/src/c.zig index bb4fd98..71a5b0e 100644 --- a/src/c.zig +++ b/src/c.zig @@ -9,8 +9,6 @@ pub usingnamespace @cImport({ if (build_options.enable_aaudio) { @cInclude("aaudio/AAudio.h"); } - if (build_options.enable_opensl) { - @cInclude("SLES/OpenSLES.h"); - @cInclude("SLES/OpenSLES_Android.h"); - } }); + +pub usingnamespace if (build_options.enable_opensl) @import("OpenSLES.zig"); From 0b389da10f63ff4e8d0d7fb0422ab338e9cf5c94 Mon Sep 17 00:00:00 2001 From: pfg Date: Sat, 28 Sep 2024 13:28:04 -0500 Subject: [PATCH 5/7] update build script to compile with zig 0.14.0-dev.1583+812557bfd --- .gitignore | 1 + Sdk.zig | 134 +++++++++++++++++++++--------------------- build.zig | 6 +- build/auto-detect.zig | 16 ++--- 4 files changed, 80 insertions(+), 77 deletions(-) diff --git a/.gitignore b/.gitignore index a769cf7..dec1194 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ zig-cache .build_config zig-out *.apk.idsig +.zig-cache \ No newline at end of file diff --git a/Sdk.zig b/Sdk.zig index 839a03b..5ee5c60 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -27,7 +27,7 @@ pub fn toolchainHostTag() []const u8 { const Sdk = @This(); /// The builder instance associated with this object. -b: *Builder, +b: *Build, /// A set of tools that run on the build host that are required to complete the /// project build. Must be created with the `hostTools()` function that passes in @@ -52,7 +52,7 @@ pub const ADBLaunchMethod = enum { /// Initializes the android SDK. /// It requires some input on which versions of the tool chains should be used -pub fn init(b: *Builder, user_config: ?UserConfig, toolchains: ToolchainVersions) *Sdk { +pub fn init(b: *Build, user_config: ?UserConfig, toolchains: ToolchainVersions) *Sdk { const actual_user_config = user_config orelse auto_detect.findUserConfig(b, toolchains) catch |err| @panic(@errorName(err)); const system_tools = blk: { @@ -88,14 +88,16 @@ pub fn init(b: *Builder, user_config: ?UserConfig, toolchains: ToolchainVersions const host_tools = blk: { const zip_add = b.addExecutable(.{ .name = "zip_add", - .root_source_file = .{ .path = sdkRoot() ++ "/tools/zip_add.zig" }, + .root_source_file = b.path(sdkRoot() ++ "/tools/zip_add.zig"), + .target = b.resolveTargetQuery(.{}), + .optimize = .Debug, }); - zip_add.addCSourceFile(.{ .file = .{ .path = sdkRoot() ++ "/vendor/kuba-zip/zip.c" }, .flags = &[_][]const u8{ + zip_add.addCSourceFile(.{ .file = b.path(sdkRoot() ++ "/vendor/kuba-zip/zip.c"), .flags = &[_][]const u8{ "-std=c99", "-fno-sanitize=undefined", "-D_POSIX_C_SOURCE=200112L", } }); - zip_add.addIncludePath(.{ .path = sdkRoot() ++ "/vendor/kuba-zip" }); + zip_add.addIncludePath(b.path(sdkRoot() ++ "/vendor/kuba-zip")); zip_add.linkLibC(); break :blk HostTools{ @@ -170,7 +172,7 @@ pub const Resource = struct { /// This is the relative path to the resource root path: []const u8, /// This is the content of the file. - content: std.build.FileSource, + content: std.Build.LazyPath, }; /// Configuration of an application. @@ -230,7 +232,7 @@ pub const KeyStore = struct { }; pub const HostTools = struct { - zip_add: *std.build.LibExeObjStep, + zip_add: *Step.Compile, }; /// Configuration of the binary paths to all tools that are not included in the android SDK. @@ -257,20 +259,20 @@ pub const AppTargetConfig = struct { pub const CreateAppStep = struct { sdk: *Sdk, - first_step: *std.build.Step, - final_step: *std.build.Step, + first_step: *std.Build.Step, + final_step: *std.Build.Step, - libraries: []const *std.build.LibExeObjStep, + libraries: []const *std.Build.Step.Compile, build_options: *BuildOptionStep, - apk_file: std.build.FileSource, + apk_file: std.Build.LazyPath, package_name: []const u8, pub fn getAndroidPackage(self: @This(), name: []const u8) std.build.Pkg { return self.sdk.b.dupePkg(std.build.Pkg{ .name = name, - .source = .{ .path = sdkRoot() ++ "/src/android-support.zig" }, + .source = self.sdk.b.path(sdkRoot() ++ "/src/android-support.zig"), .dependencies = &[_]std.build.Pkg{ self.build_options.getPackage("build_options"), }, @@ -501,7 +503,7 @@ pub fn createApp( } resource_dir_step.add(Resource{ .path = "values/strings.xml", - .content = write_xml_step.files.items[0].getPath(), + .content = write_xml_step.getDirectory().path(sdk.b, write_xml_step.files.items[0].sub_path), }); const sdk_version_int = @intFromEnum(app_config.target_version); @@ -547,7 +549,7 @@ pub fn createApp( const unaligned_apk_file = make_unsigned_apk.addOutputFileArg(unaligned_apk_name); make_unsigned_apk.addArg("-M"); // specify full path to AndroidManifest.xml to include in zip - make_unsigned_apk.addFileArg(manifest_step.files.items[0].getPath()); + make_unsigned_apk.addFileArg(manifest_step.getDirectory().path(sdk.b, manifest_step.files.items[0].sub_path)); make_unsigned_apk.addArg("-S"); // directory in which to find resources. Multiple directories will be scanned and the first match found (left to right) will take precedence make_unsigned_apk.addDirectoryArg(resource_dir_step.getOutputDirectory()); @@ -565,7 +567,7 @@ pub fn createApp( const copy_to_zip_step = WriteToZip.init(sdk, unaligned_apk_file, unaligned_apk_name); copy_to_zip_step.run_step.step.dependOn(&make_unsigned_apk.step); - var libs = std.ArrayList(*std.build.LibExeObjStep).init(sdk.b.allocator); + var libs = std.ArrayList(*std.Build.Step.Compile).init(sdk.b.allocator); defer libs.deinit(); const build_options = BuildOptionStep.create(sdk.b); @@ -576,8 +578,8 @@ pub fn createApp( build_options.add(bool, "enable_opensl", app_config.opensl); const android_module = sdk.b.addModule("android", .{ - .source_file = .{ .path = "src/android-support.zig" }, - .dependencies = &.{.{ + .root_source_file = sdk.b.path("src/android-support.zig"), + .imports = &.{.{ .name = "build_options", .module = build_options.getModule(), }}, @@ -610,13 +612,13 @@ pub fn createApp( "-d", java_dir, }); - javac_cmd.addFileArg(std.build.FileSource.relative(java_file)); + javac_cmd.addFileArg(.{ .cwd_relative = java_file }); const name = std.fs.path.stem(java_file); const name_ext = sdk.b.fmt("{s}.class", .{name}); const class_file = std.fs.path.resolve(sdk.b.allocator, &[_][]const u8{ java_dir, name_ext }) catch unreachable; - d8_cmd_builder.addFileArg(.{ .path = class_file }); + d8_cmd_builder.addFileArg(sdk.b.path(class_file)); d8_cmd_builder.step.dependOn(&javac_cmd.step); } @@ -630,7 +632,7 @@ pub fn createApp( const dex_file = std.fs.path.resolve(sdk.b.allocator, &[_][]const u8{ java_dir, "classes.dex" }) catch unreachable; // make_unsigned_apk.addArg("-I"); // make_unsigned_apk.addArg(dex_file); - copy_to_zip_step.addFile(.{ .path = dex_file }, "classes.dex"); + copy_to_zip_step.addFile(sdk.b.path(dex_file), "classes.dex"); copy_to_zip_step.run_step.step.dependOn(&make_unsigned_apk.step); // enforces creation of APK before the execution align_step.step.dependOn(©_to_zip_step.run_step.step); } @@ -681,7 +683,7 @@ pub fn createApp( const target_filename = sdk.b.fmt("{s}lib{s}.so", .{ so_dir, app_config.app_name }); - copy_to_zip_step.addFile(step.getOutputSource(), target_filename); + copy_to_zip_step.addFile(step.getEmittedBin(), target_filename); copy_to_zip_step.run_step.step.dependOn(&step.step); // why this is inside the for loop align_step.step.dependOn(©_to_zip_step.run_step.step); @@ -704,13 +706,13 @@ pub fn createApp( const CreateResourceDirectory = struct { const Self = @This(); - builder: *std.build.Builder, - step: std.build.Step, + builder: *Build, + step: std.Build.Step, resources: std.ArrayList(Resource), - directory: std.build.GeneratedFile, + directory: std.Build.GeneratedFile, - pub fn create(b: *std.build.Builder) *Self { + pub fn create(b: *Build) *Self { const self = b.allocator.create(Self) catch @panic("out of memory"); self.* = Self{ .builder = b, @@ -734,13 +736,13 @@ const CreateResourceDirectory = struct { resource.content.addStepDependencies(&self.step); } - pub fn getOutputDirectory(self: *Self) std.build.FileSource { - return .{ .generated = &self.directory }; + pub fn getOutputDirectory(self: *Self) std.Build.LazyPath { + return .{ .generated = .{ .file = &self.directory } }; } - fn make(step: *Step, progress: *std.Progress.Node) !void { - _ = progress; - const self = @fieldParentPtr(Self, "step", step); + fn make(step: *Step, opts: std.Build.Step.MakeOptions) !void { + _ = opts; + const self: *Self = @fieldParentPtr("step", step); // if (std.fs.path.dirname(strings_xml)) |dir| { // std.fs.cwd().makePath(dir) catch unreachable; @@ -783,10 +785,10 @@ fn run_copy_to_zip(sdk: *Sdk, input_file: std.build.FileSource, apk_file: std.bu } const WriteToZip = struct { - output_source: std.Build.FileSource, - run_step: *std.Build.RunStep, + output_source: std.Build.LazyPath, + run_step: *std.Build.Step.Run, - pub fn init(sdk: *Sdk, zip_file: std.Build.FileSource, out_name: []const u8) WriteToZip { + pub fn init(sdk: *Sdk, zip_file: std.Build.LazyPath, out_name: []const u8) WriteToZip { const run_cp = sdk.b.addRunArtifact(sdk.host_tools.zip_add); run_cp.addFileArg(zip_file); @@ -798,7 +800,7 @@ const WriteToZip = struct { }; } - pub fn addFile(step: *const WriteToZip, input_file: std.Build.FileSource, target_file: []const u8) void { + pub fn addFile(step: *const WriteToZip, input_file: std.Build.LazyPath, target_file: []const u8) void { step.run_step.addFileArg(input_file); step.run_step.addArg(target_file); } @@ -813,14 +815,14 @@ pub fn compileAppLibrary( mode: std.builtin.Mode, target: Target, // build_options: std.build.Pkg, -) *std.build.LibExeObjStep { +) *std.Build.Step.Compile { const ndk_root = sdk.b.pathFromRoot(sdk.folders.android_ndk_root); const TargetConfig = struct { lib_dir: []const u8, include_dir: []const u8, out_dir: []const u8, - target: std.zig.CrossTarget, + target: std.Target.Query, }; const config: TargetConfig = switch (target) { @@ -871,29 +873,29 @@ pub fn compileAppLibrary( const exe = sdk.b.addSharedLibrary(.{ .name = app_config.app_name, - .root_source_file = .{ .path = src_file }, - .target = config.target, + .root_source_file = sdk.b.path(src_file), + .target = sdk.b.resolveTargetQuery(config.target), .optimize = mode, + .pic = true, + .strip = mode == .ReleaseSmall, // isn't this automatic? }); exe.link_emit_relocs = true; exe.link_eh_frame_hdr = true; - exe.force_pic = true; exe.link_function_sections = true; exe.bundle_compiler_rt = true; - exe.strip = (mode == .ReleaseSmall); exe.export_table = true; exe.defineCMacro("ANDROID", null); exe.linkLibC(); for (app_config.libraries) |lib| { - exe.linkSystemLibraryName(lib); + exe.linkSystemLibrary(lib); } // exe.addIncludePath(include_dir); - exe.addLibraryPath(.{ .path = lib_dir }); + exe.addLibraryPath(sdk.b.path(lib_dir)); // exe.addIncludePath(include_dir); // exe.addIncludePath(system_include_dir); @@ -902,14 +904,14 @@ pub fn compileAppLibrary( exe.libc_file.?.addStepDependencies(&exe.step); // TODO: Remove when https://github.com/ziglang/zig/issues/7935 is resolved: - if (exe.target.getCpuArch() == .x86) { + if (exe.rootModuleTarget().cpu.arch == .x86) { exe.link_z_notext = true; } return exe; } -fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const u8, include_dir: []const u8, sys_include_dir: []const u8, crt_dir: []const u8) !std.build.FileSource { +fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const u8, include_dir: []const u8, sys_include_dir: []const u8, crt_dir: []const u8) !std.Build.LazyPath { const fname = sdk.b.fmt("android-{d}-{s}.conf", .{ @intFromEnum(version), folder_name }); var contents = std.ArrayList(u8).init(sdk.b.allocator); @@ -933,7 +935,7 @@ fn createLibCFile(sdk: *const Sdk, version: AndroidVersion, folder_name: []const const step = sdk.b.addWriteFile(fname, contents.items); // return step.getFileSource(fname) orelse unreachable; - return step.files.items[0].getPath(); + return step.getDirectory().path(sdk.b, step.files.items[0].sub_path); } pub fn compressApk(sdk: Sdk, input_apk_file: []const u8, output_apk_file: []const u8) *Step { @@ -971,7 +973,7 @@ pub fn compressApk(sdk: Sdk, input_apk_file: []const u8, output_apk_file: []cons return &rmdir_cmd.step; } -pub fn installApp(sdk: Sdk, apk_file: std.build.FileSource) *Step { +pub fn installApp(sdk: Sdk, apk_file: std.Build.LazyPath) *Step { const step = sdk.b.addSystemCommand(&[_][]const u8{ sdk.system_tools.adb, "install" }); step.addFileArg(apk_file); return &step.step; @@ -1041,14 +1043,14 @@ pub fn initKeystore(sdk: Sdk, key_store: KeyStore, key_config: KeyConfig) *Step } } -const Builder = std.build.Builder; -const Step = std.build.Step; +const Build = std.Build; +const Step = Build.Step; const android_os = .linux; const android_abi = .android; const zig_targets = struct { - const aarch64 = std.zig.CrossTarget{ + const aarch64 = std.Target.Query{ .cpu_arch = .aarch64, .os_tag = android_os, .abi = android_abi, @@ -1056,7 +1058,7 @@ const zig_targets = struct { .cpu_features_add = std.Target.aarch64.featureSet(&.{.v8a}), }; - const arm = std.zig.CrossTarget{ + const arm = std.Target.Query{ .cpu_arch = .arm, .os_tag = android_os, .abi = android_abi, @@ -1064,14 +1066,14 @@ const zig_targets = struct { .cpu_features_add = std.Target.arm.featureSet(&.{.v7a}), }; - const x86 = std.zig.CrossTarget{ + const x86 = std.Target.Query{ .cpu_arch = .x86, .os_tag = android_os, .abi = android_abi, .cpu_model = .baseline, }; - const x86_64 = std.zig.CrossTarget{ + const x86_64 = std.Target.Query{ .cpu_arch = .x86_64, .os_tag = android_os, .abi = android_abi, @@ -1085,11 +1087,11 @@ const BuildOptionStep = struct { const Self = @This(); step: Step, - builder: *std.build.Builder, + builder: *Build, file_content: std.ArrayList(u8), - package_file: std.build.GeneratedFile, + package_file: std.Build.GeneratedFile, - pub fn create(b: *Builder) *Self { + pub fn create(b: *Build) *Self { const options = b.allocator.create(Self) catch @panic("out of memory"); options.* = Self{ @@ -1101,10 +1103,10 @@ const BuildOptionStep = struct { .makeFn = make, }), .file_content = std.ArrayList(u8).init(b.allocator), - .package_file = std.build.GeneratedFile{ .step = &options.step }, + .package_file = std.Build.GeneratedFile{ .step = &options.step }, }; const build_options = b.addModule("build_options", .{ - .source_file = .{ .generated = &options.package_file }, + .root_source_file = .{ .generated = .{ .file = &options.package_file } }, }); _ = build_options; @@ -1185,7 +1187,7 @@ const BuildOptionStep = struct { else => {}, } switch (@typeInfo(T)) { - .Enum => |enum_info| { + .@"enum" => |enum_info| { out.print("pub const {} = enum {{\n", .{std.zig.fmtId(@typeName(T))}) catch unreachable; inline for (enum_info.fields) |field| { out.print(" {},\n", .{std.zig.fmtId(field.name)}) catch unreachable; @@ -1197,9 +1199,9 @@ const BuildOptionStep = struct { out.print("pub const {}: {s} = {};\n", .{ std.zig.fmtId(name), @typeName(T), value }) catch unreachable; } - fn make(step: *Step, progress: *std.Progress.Node) !void { - _ = progress; - const self = @fieldParentPtr(Self, "step", step); + fn make(step: *Step, opts: std.Build.Step.MakeOptions) !void { + _ = opts; + const self: *Self = @fieldParentPtr("step", step); var cacher = createCacheBuilder(self.builder); cacher.addBytes(self.file_content.items); @@ -1211,22 +1213,22 @@ const BuildOptionStep = struct { "build_options.zig", }); - try std.fs.cwd().writeFile(self.package_file.path.?, self.file_content.items); + try std.fs.cwd().writeFile(.{ .sub_path = self.package_file.path.?, .data = self.file_content.items }); } }; -fn createCacheBuilder(b: *std.build.Builder) CacheBuilder { +fn createCacheBuilder(b: *Build) CacheBuilder { return CacheBuilder.init(b, "android-sdk"); } const CacheBuilder = struct { const Self = @This(); - builder: *std.build.Builder, + builder: *Build, hasher: std.crypto.hash.Sha1, subdir: ?[]const u8, - pub fn init(builder: *std.build.Builder, subdir: ?[]const u8) Self { + pub fn init(builder: *Build, subdir: ?[]const u8) Self { return Self{ .builder = builder, .hasher = std.crypto.hash.Sha1.init(.{}), @@ -1241,7 +1243,7 @@ const CacheBuilder = struct { self.hasher.update(bytes); } - pub fn addFile(self: *Self, file: std.build.FileSource) !void { + pub fn addFile(self: *Self, file: std.Build.LazyPath) !void { const path = file.getPath(self.builder); const data = try std.fs.cwd().readFileAlloc(self.builder.allocator, path, 1 << 32); // 4 GB diff --git a/build.zig b/build.zig index ea7a0e4..94a8690 100644 --- a/build.zig +++ b/build.zig @@ -5,7 +5,7 @@ const std = @import("std"); const Sdk = @import("Sdk.zig"); -pub fn build(b: *std.build.Builder) !void { +pub fn build(b: *std.Build) !void { // Default-initialize SDK const sdk = Sdk.init(b, null, .{}); const mode = b.standardOptimizeOption(.{}); @@ -49,7 +49,7 @@ pub fn build(b: *std.build.Builder) !void { // This is a set of resources. It should at least contain a "mipmap/icon.png" resource that // will provide the application icon. .resources = &[_]Sdk.Resource{ - .{ .path = "mipmap/icon.png", .content = .{ .path = "examples/icon.png" } }, + .{ .path = "mipmap/icon.png", .content = b.path("examples/icon.png") }, }, .aaudio = aaudio, @@ -100,7 +100,7 @@ pub fn build(b: *std.build.Builder) !void { for (app.libraries) |exe| { // Provide the "android" package in each executable we build - exe.addModule("android", android_module); + exe.root_module.addImport("android", android_module); } // Make the app build when we invoke "zig build" or "zig build install" diff --git a/build/auto-detect.zig b/build/auto-detect.zig index 7d6b506..3ed5f6a 100644 --- a/build/auto-detect.zig +++ b/build/auto-detect.zig @@ -1,6 +1,6 @@ const std = @import("std"); const builtin = @import("builtin"); -const Builder = std.build.Builder; +const Build = std.Build; const Sdk = @import("../Sdk.zig"); const UserConfig = Sdk.UserConfig; @@ -11,7 +11,7 @@ const local_config_file = "android.json"; const print = std.debug.print; -pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig { +pub fn findUserConfig(b: *Build, versions: Sdk.ToolchainVersions) !UserConfig { // var str_buf: [5]u8 = undefined; var config = UserConfig{}; @@ -367,7 +367,7 @@ pub fn findUserConfig(b: *Builder, versions: Sdk.ToolchainVersions) !UserConfig print("\n", .{}); } - std.os.exit(1); + std.process.exit(1); } if (config_dirty) { @@ -383,7 +383,7 @@ pub fn findProgramPath(allocator: std.mem.Allocator, program: []const u8) ?[]con else &[_][]const u8{ "which", program }; - var proc = std.ChildProcess.init(args, allocator); + var proc = std.process.Child.init(args, allocator); proc.stderr_behavior = .Close; proc.stdout_behavior = .Pipe; @@ -411,7 +411,7 @@ pub fn findProgramPath(allocator: std.mem.Allocator, program: []const u8) ?[]con // Returns the problem with an android_home path. // If it seems alright, returns null. -fn findProblemWithAndroidSdk(b: *Builder, versions: Sdk.ToolchainVersions, path: []const u8) ?[]const u8 { +fn findProblemWithAndroidSdk(b: *Build, versions: Sdk.ToolchainVersions, path: []const u8) ?[]const u8 { std.fs.cwd().access(path, .{}) catch |err| { if (err == error.FileNotFound) return "Directory does not exist"; return b.fmt("Cannot access {s}, {s}", .{ path, @errorName(err) }); @@ -449,7 +449,7 @@ fn findProblemWithAndroidSdk(b: *Builder, versions: Sdk.ToolchainVersions, path: // Returns the problem with an android ndk path. // If it seems alright, returns null. -fn findProblemWithAndroidNdk(b: *Builder, versions: Sdk.ToolchainVersions, path: []const u8) ?[]const u8 { +fn findProblemWithAndroidNdk(b: *Build, versions: Sdk.ToolchainVersions, path: []const u8) ?[]const u8 { std.fs.cwd().access(path, .{}) catch |err| { if (err == error.FileNotFound) return "Directory does not exist"; return b.fmt("Cannot access {s}, {s}", .{ path, @errorName(err) }); @@ -474,7 +474,7 @@ fn findProblemWithAndroidNdk(b: *Builder, versions: Sdk.ToolchainVersions, path: // Returns the problem with a jdk install. // If it seems alright, returns null. -fn findProblemWithJdk(b: *Builder, path: []const u8) ?[]const u8 { +fn findProblemWithJdk(b: *Build, path: []const u8) ?[]const u8 { std.fs.cwd().access(path, .{}) catch |err| { if (err == error.FileNotFound) return "Directory does not exist"; return b.fmt("Cannot access {s}, {s}", .{ path, @errorName(err) }); @@ -489,7 +489,7 @@ fn findProblemWithJdk(b: *Builder, path: []const u8) ?[]const u8 { return null; } -fn pathConcat(b: *Builder, left: []const u8, right: []const u8) []const u8 { +fn pathConcat(b: *Build, left: []const u8, right: []const u8) []const u8 { return std.fs.path.join(b.allocator, &[_][]const u8{ left, right }) catch unreachable; } From c408d6706031502024297c3db74e7762ed6d8ce7 Mon Sep 17 00:00:00 2001 From: pfg Date: Sat, 28 Sep 2024 13:44:06 -0500 Subject: [PATCH 6/7] WIP updating code to 0.14 --- Sdk.zig | 2 +- examples/egl/main.zig | 14 +++++++------- src/android-support.zig | 22 +++++++++++----------- src/jni.zig | 4 ++-- 4 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Sdk.zig b/Sdk.zig index 5ee5c60..b72fd84 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -895,7 +895,7 @@ pub fn compileAppLibrary( // exe.addIncludePath(include_dir); - exe.addLibraryPath(sdk.b.path(lib_dir)); + exe.addLibraryPath(.{ .cwd_relative = lib_dir }); // exe.addIncludePath(include_dir); // exe.addIncludePath(system_include_dir); diff --git a/examples/egl/main.zig b/examples/egl/main.zig index e421299..a0e5497 100644 --- a/examples/egl/main.zig +++ b/examples/egl/main.zig @@ -74,7 +74,7 @@ pub const AndroidApp = struct { /// Uninitialize the application. /// Don't forget to stop your background thread here! pub fn deinit(self: *Self) void { - @atomicStore(bool, &self.running, false, .SeqCst); + @atomicStore(bool, &self.running, false, .seq_cst); if (self.thread) |thread| { thread.join(); self.thread = null; @@ -413,7 +413,7 @@ pub const AndroidApp = struct { 1.0, 1.0, }; - while (@atomicLoad(bool, &self.running, .SeqCst)) { + while (@atomicLoad(bool, &self.running, .seq_cst)) { // Input process { @@ -846,7 +846,7 @@ const Oscillator = struct { amplitude: f64 = 0.1, fn setWaveOn(self: *@This(), isWaveOn: bool) void { - @atomicStore(bool, &self.isWaveOn, isWaveOn, .SeqCst); + @atomicStore(bool, &self.isWaveOn, isWaveOn, .seq_cst); } fn setSampleRate(self: *@This(), sample_rate: i32) void { @@ -854,10 +854,10 @@ const Oscillator = struct { } fn renderf32(self: *@This(), audio_data: []f32) void { - if (!@atomicLoad(bool, &self.isWaveOn, .SeqCst)) self.phase = 0; + if (!@atomicLoad(bool, &self.isWaveOn, .seq_cst)) self.phase = 0; for (audio_data) |*frame| { - if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { + if (@atomicLoad(bool, &self.isWaveOn, .seq_cst)) { frame.* += @as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)); self.phase += self.phaseIncrement; if (self.phase > std.math.tau) self.phase -= std.math.tau; @@ -866,10 +866,10 @@ const Oscillator = struct { } fn renderi16(self: *@This(), audio_data: []i16) void { - if (!@atomicLoad(bool, &self.isWaveOn, .SeqCst)) self.phase = 0; + if (!@atomicLoad(bool, &self.isWaveOn, .seq_cst)) self.phase = 0; for (audio_data) |*frame| { - if (@atomicLoad(bool, &self.isWaveOn, .SeqCst)) { + if (@atomicLoad(bool, &self.isWaveOn, .seq_cst)) { frame.* +|= @as(i16, @intFromFloat(@as(f32, @floatCast(std.math.sin(self.phase) * self.amplitude)) * std.math.maxInt(i16))); self.phase += self.phaseIncrement; if (self.phase > std.math.tau) self.phase -= std.math.tau; diff --git a/src/android-support.zig b/src/android-support.zig index 68c6c48..975934e 100644 --- a/src/android-support.zig +++ b/src/android-support.zig @@ -101,14 +101,14 @@ var recursive_panic = false; pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usize) noreturn { var logger = LogWriter{ .log_level = android.ANDROID_LOG_ERROR }; - if (@atomicLoad(bool, &recursive_panic, .SeqCst)) { + if (@atomicLoad(bool, &recursive_panic, .seq_cst)) { logger.writer().print("RECURSIVE PANIC: {s}\n", .{message}) catch {}; while (true) { std.time.sleep(std.time.ns_per_week); } } - @atomicStore(bool, &recursive_panic, true, .SeqCst); + @atomicStore(bool, &recursive_panic, true, .seq_cst); logger.writer().print("PANIC: {s}\n", .{message}) catch {}; @@ -140,7 +140,7 @@ pub fn panic(message: []const u8, stack_trace: ?*std.builtin.StackTrace, _: ?usi logger.writer().writeAll("<-- end of stack trace -->\n") catch {}; - std.os.exit(1); + std.process.exit(1); } const LogWriter = struct { @@ -231,9 +231,9 @@ fn makeNativeActivityGlue(comptime App: type) android.ANativeActivityCallbacks { if (activity.instance) |instance| { const result = @call(.auto, @field(App, func), .{@as(*App, @ptrCast(@alignCast(instance)))} ++ args); switch (@typeInfo(@TypeOf(result))) { - .ErrorUnion => result catch |err| app_log.err("{s} returned error {s}", .{ func, @errorName(err) }), - .Void => {}, - .ErrorSet => app_log.err("{s} returned error {s}", .{ func, @errorName(result) }), + .error_union => result catch |err| app_log.err("{s} returned error {s}", .{ func, @errorName(err) }), + .void => {}, + .error_set => app_log.err("{s} returned error {s}", .{ func, @errorName(result) }), else => @compileError("callback must return void!"), } } @@ -329,7 +329,7 @@ fn makeNativeActivityGlue(comptime App: type) android.ANativeActivityCallbacks { }; } -inline fn printSymbolInfoAt(st_index: usize, maybe_debug_info: ?*std.debug.DebugInfo, int_addr: usize) void { +inline fn printSymbolInfoAt(st_index: usize, maybe_debug_info: ?*std.debug.SelfInfo, int_addr: usize) void { var symbol_name_buffer: [1024]u8 = undefined; var symbol_name: ?[]const u8 = null; @@ -346,9 +346,9 @@ inline fn printSymbolInfoAt(st_index: usize, maybe_debug_info: ?*std.debug.Debug &symbol_name_buffer, "{s} {s} {s}", .{ - symbol.symbol_name, + symbol.name, symbol.compile_unit_name, - fmtMaybeLineInfo(symbol.line_info), + fmtMaybeLineInfo(symbol.source_location), }, ) catch symbol_name; } else |_| {} @@ -362,7 +362,7 @@ inline fn printSymbolInfoAt(st_index: usize, maybe_debug_info: ?*std.debug.Debug }); } -fn realFmtMaybeLineInfo(self: ?std.debug.LineInfo, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void { +fn realFmtMaybeLineInfo(self: ?std.debug.SourceLocation, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void { _ = fmt; _ = options; if (self) |li| { @@ -376,7 +376,7 @@ fn realFmtMaybeLineInfo(self: ?std.debug.LineInfo, comptime fmt: []const u8, opt } } -fn fmtMaybeLineInfo(li: ?std.debug.LineInfo) std.fmt.Formatter(realFmtMaybeLineInfo) { +fn fmtMaybeLineInfo(li: ?std.debug.SourceLocation) std.fmt.Formatter(realFmtMaybeLineInfo) { return std.fmt.Formatter(realFmtMaybeLineInfo){ .data = li, }; diff --git a/src/jni.zig b/src/jni.zig index d27285f..b3f83cb 100644 --- a/src/jni.zig +++ b/src/jni.zig @@ -10,8 +10,8 @@ const android = @import("android-support.zig"); pub const JNI = opaque { // Underlying implementation fn JniReturnType(comptime function: @TypeOf(.literal)) type { - @setEvalBranchQuota(10_000); - return @typeInfo(@typeInfo(std.meta.fieldInfo(android.JNINativeInterface, function).type).Pointer.child).Fn.return_type.?; + @setEvalBranchQuota(100_000); + return @typeInfo(@typeInfo(std.meta.fieldInfo(android.JNINativeInterface, function).type).pointer.child).@"fn".return_type.?; } pub inline fn invokeJniNoException(jni: *JNI, comptime function: @TypeOf(.literal), args: anytype) JniReturnType(function) { From 6b3c134ec426cb2aa0793e2f1ff907194769f275 Mon Sep 17 00:00:00 2001 From: pfg Date: Sat, 28 Sep 2024 21:16:41 -0500 Subject: [PATCH 7/7] eliminate sdkRoot(), it's the same as 'b.path()' --- Sdk.zig | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/Sdk.zig b/Sdk.zig index b72fd84..abe79a1 100644 --- a/Sdk.zig +++ b/Sdk.zig @@ -7,15 +7,6 @@ const builtin = @import("builtin"); const auto_detect = @import("build/auto-detect.zig"); -fn sdkRootIntern() []const u8 { - return std.fs.path.dirname(@src().file) orelse "."; -} - -fn sdkRoot() *const [sdkRootIntern().len]u8 { - comptime var buffer = sdkRootIntern(); - return buffer[0..buffer.len]; -} - // linux-x86_64 pub fn toolchainHostTag() []const u8 { const os = builtin.os.tag; @@ -88,16 +79,16 @@ pub fn init(b: *Build, user_config: ?UserConfig, toolchains: ToolchainVersions) const host_tools = blk: { const zip_add = b.addExecutable(.{ .name = "zip_add", - .root_source_file = b.path(sdkRoot() ++ "/tools/zip_add.zig"), + .root_source_file = b.path("tools/zip_add.zig"), .target = b.resolveTargetQuery(.{}), .optimize = .Debug, }); - zip_add.addCSourceFile(.{ .file = b.path(sdkRoot() ++ "/vendor/kuba-zip/zip.c"), .flags = &[_][]const u8{ + zip_add.addCSourceFile(.{ .file = b.path("vendor/kuba-zip/zip.c"), .flags = &[_][]const u8{ "-std=c99", "-fno-sanitize=undefined", "-D_POSIX_C_SOURCE=200112L", } }); - zip_add.addIncludePath(b.path(sdkRoot() ++ "/vendor/kuba-zip")); + zip_add.addIncludePath(b.path("vendor/kuba-zip")); zip_add.linkLibC(); break :blk HostTools{ @@ -272,7 +263,7 @@ pub const CreateAppStep = struct { pub fn getAndroidPackage(self: @This(), name: []const u8) std.build.Pkg { return self.sdk.b.dupePkg(std.build.Pkg{ .name = name, - .source = self.sdk.b.path(sdkRoot() ++ "/src/android-support.zig"), + .source = self.sdk.b.path("src/android-support.zig"), .dependencies = &[_]std.build.Pkg{ self.build_options.getPackage("build_options"), },