noobs 0.0.6

package/include/util/source-profiler.h

@@ -0,0 +1,66 @@
+/******************************************************************************
+    Copyright (C) 2023 by Dennis Sädtler <dennis@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "obs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct profiler_result {
+	/* Tick times in ns */
+	uint64_t tick_avg;
+	uint64_t tick_max;
+
+	/* Average and max render times for CPU and GPU in ns */
+	uint64_t render_avg;
+	uint64_t render_max;
+	uint64_t render_gpu_avg;
+	uint64_t render_gpu_max;
+
+	/* Average of the sum of all render passes in a frame in ns
+	 * (a source can be rendered more than once per frame). */
+	uint64_t render_sum;
+	uint64_t render_gpu_sum;
+
+	/* FPS of submitted async input */
+	double async_input;
+	/* Actually rendered async frames */
+	double async_rendered;
+
+	/* Best and worst frame times of input/output in ns */
+	uint64_t async_input_best;
+	uint64_t async_input_worst;
+	uint64_t async_rendered_best;
+	uint64_t async_rendered_worst;
+} profiler_result_t;
+
+/* Enable/disable profiler (applied on next frame) */
+EXPORT void source_profiler_enable(bool enable);
+/* Enable/disable GPU profiling (applied on next frame) */
+EXPORT void source_profiler_gpu_enable(bool enable);
+
+/* Get latest profiling results for source (must be freed by user) */
+EXPORT profiler_result_t *source_profiler_get_result(obs_source_t *source);
+/* Update existing profiler results object for source */
+EXPORT bool source_profiler_fill_result(obs_source_t *source, profiler_result_t *result);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/sse-intrin.h

@@ -0,0 +1,32 @@
+/******************************************************************************
+    Copyright (C) 2019 by Peter Geis <pgwipeout@gmail.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "c99defs.h"
+
+#if (defined(_MSC_VER) || defined(__MINGW32__)) && ((defined(_M_X64) && !defined(_M_ARM64EC)) || defined(_M_IX86))
+#include <emmintrin.h>
+#else
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#define SIMDE_ENABLE_NATIVE_ALIASES
+PRAGMA_WARN_PUSH
+#include "simde/x86/sse2.h"
+PRAGMA_WARN_POP
+#endif

package/include/util/task.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct os_task_queue;
+typedef struct os_task_queue os_task_queue_t;
+
+typedef void (*os_task_t)(void *param);
+
+EXPORT os_task_queue_t *os_task_queue_create(void);
+EXPORT bool os_task_queue_queue_task(os_task_queue_t *tt, os_task_t task, void *param);
+EXPORT void os_task_queue_destroy(os_task_queue_t *tt);
+EXPORT bool os_task_queue_wait(os_task_queue_t *tt);
+EXPORT bool os_task_queue_inside(os_task_queue_t *tt);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/text-lookup.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+/*
+ * Text Lookup interface
+ *
+ *   Used for storing and looking up localized strings.  Stores localization
+ *   strings in a hashmap to efficiently look up associated strings via a
+ *   unique string identifier name.
+ */
+
+#include "c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* opaque typedef */
+struct text_lookup;
+typedef struct text_lookup lookup_t;
+
+/* functions */
+EXPORT lookup_t *text_lookup_create(const char *path);
+EXPORT bool text_lookup_add(lookup_t *lookup, const char *path);
+EXPORT void text_lookup_destroy(lookup_t *lookup);
+EXPORT bool text_lookup_getstr(lookup_t *lookup, const char *lookup_val, const char **out);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/threading-posix.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+static inline long os_atomic_inc_long(volatile long *val)
+{
+	return __atomic_add_fetch(val, 1, __ATOMIC_SEQ_CST);
+}
+
+static inline long os_atomic_dec_long(volatile long *val)
+{
+	return __atomic_sub_fetch(val, 1, __ATOMIC_SEQ_CST);
+}
+
+static inline void os_atomic_store_long(volatile long *ptr, long val)
+{
+	__atomic_store_n(ptr, val, __ATOMIC_SEQ_CST);
+}
+
+static inline long os_atomic_set_long(volatile long *ptr, long val)
+{
+	return __atomic_exchange_n(ptr, val, __ATOMIC_SEQ_CST);
+}
+
+static inline long os_atomic_exchange_long(volatile long *ptr, long val)
+{
+	return os_atomic_set_long(ptr, val);
+}
+
+static inline long os_atomic_load_long(const volatile long *ptr)
+{
+	return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);
+}
+
+static inline bool os_atomic_compare_swap_long(volatile long *val, long old_val, long new_val)
+{
+	return __atomic_compare_exchange_n(val, &old_val, new_val, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+static inline bool os_atomic_compare_exchange_long(volatile long *val, long *old_val, long new_val)
+{
+	return __atomic_compare_exchange_n(val, old_val, new_val, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
+}
+
+static inline void os_atomic_store_bool(volatile bool *ptr, bool val)
+{
+	__atomic_store_n(ptr, val, __ATOMIC_SEQ_CST);
+}
+
+static inline bool os_atomic_set_bool(volatile bool *ptr, bool val)
+{
+	return __atomic_exchange_n(ptr, val, __ATOMIC_SEQ_CST);
+}
+
+static inline bool os_atomic_exchange_bool(volatile bool *ptr, bool val)
+{
+	return os_atomic_set_bool(ptr, val);
+}
+
+static inline bool os_atomic_load_bool(const volatile bool *ptr)
+{
+	return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);
+}

package/include/util/threading-windows.h

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+#include <intrin.h>
+#include <string.h>
+
+#if !defined(_M_IX86) && !defined(_M_X64) && !defined(_M_ARM) && !defined(_M_ARM64)
+#error Processor not supported
+#endif
+
+static inline long os_atomic_inc_long(volatile long *val)
+{
+	return _InterlockedIncrement(val);
+}
+
+static inline long os_atomic_dec_long(volatile long *val)
+{
+	return _InterlockedDecrement(val);
+}
+
+static inline void os_atomic_store_long(volatile long *ptr, long val)
+{
+#if defined(_M_ARM64)
+	_ReadWriteBarrier();
+	__stlr32((volatile unsigned *)ptr, val);
+	_ReadWriteBarrier();
+#elif defined(_M_ARM)
+	__dmb(_ARM_BARRIER_ISH);
+	__iso_volatile_store32((volatile __int32 *)ptr, val);
+	__dmb(_ARM_BARRIER_ISH);
+#else
+	_InterlockedExchange(ptr, val);
+#endif
+}
+
+static inline long os_atomic_set_long(volatile long *ptr, long val)
+{
+	return _InterlockedExchange(ptr, val);
+}
+
+static inline long os_atomic_exchange_long(volatile long *ptr, long val)
+{
+	return os_atomic_set_long(ptr, val);
+}
+
+static inline long os_atomic_load_long(const volatile long *ptr)
+{
+#if defined(_M_ARM64)
+	const long val = __ldar32((volatile unsigned *)ptr);
+#else
+	const long val = __iso_volatile_load32((const volatile __int32 *)ptr);
+#endif
+
+#if defined(_M_ARM)
+	__dmb(_ARM_BARRIER_ISH);
+#else
+	_ReadWriteBarrier();
+#endif
+
+	return val;
+}
+
+static inline bool os_atomic_compare_swap_long(volatile long *val, long old_val, long new_val)
+{
+	return _InterlockedCompareExchange(val, new_val, old_val) == old_val;
+}
+
+static inline bool os_atomic_compare_exchange_long(volatile long *val, long *old_ptr, long new_val)
+{
+	const long old_val = *old_ptr;
+	const long previous = _InterlockedCompareExchange(val, new_val, old_val);
+	*old_ptr = previous;
+	return previous == old_val;
+}
+
+static inline void os_atomic_store_bool(volatile bool *ptr, bool val)
+{
+#if defined(_M_ARM64)
+	_ReadWriteBarrier();
+	__stlr8((volatile unsigned char *)ptr, val);
+	_ReadWriteBarrier();
+#elif defined(_M_ARM)
+	__dmb(_ARM_BARRIER_ISH);
+	__iso_volatile_store8((volatile char *)ptr, val);
+	__dmb(_ARM_BARRIER_ISH);
+#else
+	_InterlockedExchange8((volatile char *)ptr, (char)val);
+#endif
+}
+
+static inline bool os_atomic_set_bool(volatile bool *ptr, bool val)
+{
+	const char c = _InterlockedExchange8((volatile char *)ptr, (char)val);
+	bool b;
+
+	/* Avoid unnecesary char to bool conversion. Value known 0 or 1. */
+	memcpy(&b, &c, sizeof(b));
+
+	return b;
+}
+
+static inline bool os_atomic_exchange_bool(volatile bool *ptr, bool val)
+{
+	return os_atomic_set_bool(ptr, val);
+}
+
+static inline bool os_atomic_load_bool(const volatile bool *ptr)
+{
+	bool b;
+
+#if defined(_M_ARM64)
+	const unsigned char c = __ldar8((volatile unsigned char *)ptr);
+#else
+	const char c = __iso_volatile_load8((const volatile char *)ptr);
+#endif
+
+#if defined(_M_ARM)
+	__dmb(_ARM_BARRIER_ISH);
+#else
+	_ReadWriteBarrier();
+#endif
+
+	/* Avoid unnecesary char to bool conversion. Value known 0 or 1. */
+	memcpy(&b, &c, sizeof(b));
+
+	return b;
+}

package/include/util/threading.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+/*
+ *   Allows posix thread usage on windows as well as other operating systems.
+ * Use this header if you want to make your code more platform independent.
+ *
+ *   Also provides a custom platform-independent "event" handler via
+ * pthread conditional waits.
+ */
+
+#include "c99defs.h"
+
+#ifndef _MSC_VER
+#include <errno.h>
+#endif
+#include <pthread.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32
+#include "threading-windows.h"
+#else
+#include "threading-posix.h"
+#endif
+
+/* this may seem strange, but you can't use it unless it's an initializer */
+static inline void pthread_mutex_init_value(pthread_mutex_t *mutex)
+{
+	pthread_mutex_t init_val = PTHREAD_MUTEX_INITIALIZER;
+	if (!mutex)
+		return;
+
+	*mutex = init_val;
+}
+
+static inline int pthread_mutex_init_recursive(pthread_mutex_t *mutex)
+{
+	pthread_mutexattr_t attr;
+	int ret = pthread_mutexattr_init(&attr);
+	if (ret == 0) {
+		ret = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+		if (ret == 0) {
+			ret = pthread_mutex_init(mutex, &attr);
+		}
+
+		pthread_mutexattr_destroy(&attr);
+	}
+
+	return ret;
+}
+
+enum os_event_type {
+	OS_EVENT_TYPE_AUTO,
+	OS_EVENT_TYPE_MANUAL,
+};
+
+struct os_event_data;
+struct os_sem_data;
+typedef struct os_event_data os_event_t;
+typedef struct os_sem_data os_sem_t;
+
+EXPORT int os_event_init(os_event_t **event, enum os_event_type type);
+EXPORT void os_event_destroy(os_event_t *event);
+EXPORT int os_event_wait(os_event_t *event);
+EXPORT int os_event_timedwait(os_event_t *event, unsigned long milliseconds);
+EXPORT int os_event_try(os_event_t *event);
+EXPORT int os_event_signal(os_event_t *event);
+EXPORT void os_event_reset(os_event_t *event);
+
+EXPORT int os_sem_init(os_sem_t **sem, int value);
+EXPORT void os_sem_destroy(os_sem_t *sem);
+EXPORT int os_sem_post(os_sem_t *sem);
+EXPORT int os_sem_wait(os_sem_t *sem);
+
+EXPORT void os_set_thread_name(const char *name);
+
+#ifdef _MSC_VER
+#define THREAD_LOCAL __declspec(thread)
+#else
+#define THREAD_LOCAL __thread
+#endif
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/utf8.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2007 Alexey Vatchenko <av@bsdua.org>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+/*
+ * utf8: implementation of UTF-8 charset encoding (RFC3629).
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define UTF8_IGNORE_ERROR 0x01
+#define UTF8_SKIP_BOM 0x02
+
+size_t utf8_to_wchar(const char *in, size_t insize, wchar_t *out, size_t outsize, int flags);
+size_t wchar_to_utf8(const wchar_t *in, size_t insize, char *out, size_t outsize, int flags);
+
+#ifdef __cplusplus
+}
+#endif

package/include/util/uthash.h

@@ -0,0 +1,34 @@
+/******************************************************************************
+    Copyright (C) 2023 by Dennis Sädtler <dennis@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+/*
+ * This file (re)defines various uthash settings for use in libobs
+ */
+
+#include <uthash.h>
+
+/* Use OBS allocator */
+#undef uthash_malloc
+#undef uthash_free
+#define uthash_malloc(sz) bmalloc(sz)
+#define uthash_free(ptr, sz) bfree(ptr)
+
+/* Use SFH (Super Fast Hash) function instead of JEN */
+#undef HASH_FUNCTION
+#define HASH_FUNCTION HASH_SFH

package/include/util/util_uint128.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2023 Lain Bailey <lain@obsproject.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#pragma once
+
+struct util_uint128 {
+	union {
+		uint32_t i32[4];
+		struct {
+			uint64_t low;
+			uint64_t high;
+		};
+	};
+};
+
+typedef struct util_uint128 util_uint128_t;
+
+static inline util_uint128_t util_add128(util_uint128_t a, util_uint128_t b)
+{
+	util_uint128_t out;
+	uint64_t val;
+
+	val = (a.low & 0xFFFFFFFFULL) + (b.low & 0xFFFFFFFFULL);
+	out.i32[0] = (uint32_t)(val & 0xFFFFFFFFULL);
+	val >>= 32;
+
+	val += (a.low >> 32) + (b.low >> 32);
+	out.i32[1] = (uint32_t)val;
+	val >>= 32;
+
+	val += (a.high & 0xFFFFFFFFULL) + (b.high & 0xFFFFFFFFULL);
+	out.i32[2] = (uint32_t)(val & 0xFFFFFFFFULL);
+	val >>= 32;
+
+	val += (a.high >> 32) + (b.high >> 32);
+	out.i32[3] = (uint32_t)val;
+
+	return out;
+}
+
+static inline util_uint128_t util_lshift64_internal_32(uint64_t a)
+{
+	util_uint128_t val;
+	val.low = a << 32;
+	val.high = a >> 32;
+	return val;
+}
+
+static inline util_uint128_t util_lshift64_internal_64(uint64_t a)
+{
+	util_uint128_t val;
+	val.low = 0;
+	val.high = a;
+	return val;
+}
+
+static inline util_uint128_t util_mul64_64(uint64_t a, uint64_t b)
+{
+	util_uint128_t out;
+	uint64_t m;
+
+	m = (a & 0xFFFFFFFFULL) * (b & 0xFFFFFFFFULL);
+	out.low = m;
+	out.high = 0;
+
+	m = (a >> 32) * (b & 0xFFFFFFFFULL);
+	out = util_add128(out, util_lshift64_internal_32(m));
+
+	m = (a & 0xFFFFFFFFULL) * (b >> 32);
+	out = util_add128(out, util_lshift64_internal_32(m));
+
+	m = (a >> 32) * (b >> 32);
+	out = util_add128(out, util_lshift64_internal_64(m));
+
+	return out;
+}
+
+static inline util_uint128_t util_div128_32(util_uint128_t a, uint32_t b)
+{
+	util_uint128_t out;
+	uint64_t val = 0;
+
+	for (int i = 3; i >= 0; i--) {
+		val = (val << 32) | a.i32[i];
+		if (val < b) {
+			out.i32[i] = 0;
+			continue;
+		}
+
+		out.i32[i] = (uint32_t)(val / b);
+		val = val % b;
+	}
+
+	return out;
+}