Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 293 insertions, 0 deletions

diff --git a/spa/plugins/audiomixer/test-mix-ops.c b/spa/plugins/audiomixer/test-mix-ops.c
new file mode 100644
index 0000000..a20f7a4
--- /dev/null
+++ b/spa/plugins/audiomixer/test-mix-ops.c
@@ -0,0 +1,293 @@
+/* Spa
+ *
+ * Copyright © 2022 Wim Taymans
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <time.h>
+
+#include <spa/debug/mem.h>
+
+#include "test-helper.h"
+#include "mix-ops.c"
+
+static uint32_t cpu_flags;
+
+#define N_SAMPLES 1024
+
+static uint8_t samp_out[N_SAMPLES * 8];
+
+static void compare_mem(int i, int j, const void *m1, const void *m2, size_t size)
+{
+	int res = memcmp(m1, m2, size);
+	if (res != 0) {
+		fprintf(stderr, "%d %d %zd:\n", i, j, size);
+		spa_debug_mem(0, m1, size);
+		spa_debug_mem(0, m2, size);
+	}
+	spa_assert_se(res == 0);
+}
+
+static int run_test(const char *name, const void *src[], uint32_t n_src, const void *dst,
+		size_t dst_size, uint32_t n_samples, mix_func_t mix)
+{
+	struct mix_ops ops;
+
+	ops.fmt = SPA_AUDIO_FORMAT_F32;
+	ops.n_channels = 1;
+	ops.cpu_flags = cpu_flags;
+	mix_ops_init(&ops);
+
+	fprintf(stderr, "%s\n", name);
+
+	mix(&ops, (void *)samp_out, src, n_src, n_samples);
+	compare_mem(0, 0, samp_out, dst, dst_size);
+	return 0;
+}
+
+static void test_s8(void)
+{
+	int8_t out[] = { 0x00, 0x00, 0x00, 0x00 };
+	int8_t in_1[] = { 0x00, 0x00, 0x00, 0x00 };
+	int8_t in_2[] = { 0x7f, 0x80, 0x40, 0xc0 };
+	int8_t in_3[] = { 0x40, 0xc0, 0xc0, 0x40 };
+	int8_t in_4[] = { 0xc0, 0x40, 0x40, 0xc0 };
+	int8_t out_4[] = { 0x7f, 0x80, 0x40, 0xc0 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_s8_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_s8_c);
+	run_test("test_s8_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_s8_c);
+	run_test("test_s8_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_s8_c);
+}
+
+static void test_u8(void)
+{
+	uint8_t out[] = { 0x80, 0x80, 0x80, 0x80 };
+	uint8_t in_1[] = { 0x80, 0x80, 0x80, 0x80 };
+	uint8_t in_2[] = { 0xff, 0x00, 0xc0, 0x40 };
+	uint8_t in_3[] = { 0xc0, 0x40, 0x40, 0xc0 };
+	uint8_t in_4[] = { 0x40, 0xc0, 0xc0, 0x40 };
+	uint8_t out_4[] = { 0xff, 0x00, 0xc0, 0x40 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_u8_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_u8_c);
+	run_test("test_u8_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_u8_c);
+	run_test("test_u8_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_u8_c);
+}
+
+static void test_s16(void)
+{
+	int16_t out[] = { 0x0000, 0x0000, 0x0000, 0x0000 };
+	int16_t in_1[] = { 0x0000, 0x0000, 0x0000, 0x0000 };
+	int16_t in_2[] = { 0x7fff, 0x8000, 0x4000, 0xc000 };
+	int16_t in_3[] = { 0x4000, 0xc000, 0xc000, 0x4000 };
+	int16_t in_4[] = { 0xc000, 0x4000, 0x4000, 0xc000 };
+	int16_t out_4[] = { 0x7fff, 0x8000, 0x4000, 0xc000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_s16_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_s16_c);
+	run_test("test_s16_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_s16_c);
+	run_test("test_s16_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_s16_c);
+}
+
+static void test_u16(void)
+{
+	uint16_t out[] = { 0x8000, 0x8000, 0x8000, 0x8000 };
+	uint16_t in_1[] = { 0x8000, 0x8000, 0x8000 , 0x8000};
+	uint16_t in_2[] = { 0xffff, 0x0000, 0xc000, 0x4000 };
+	uint16_t in_3[] = { 0xc000, 0x4000, 0x4000, 0xc000 };
+	uint16_t in_4[] = { 0x4000, 0xc000, 0xc000, 0x4000 };
+	uint16_t out_4[] = { 0xffff, 0x0000, 0xc000, 0x4000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_u16_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_u16_c);
+	run_test("test_u16_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_u16_c);
+	run_test("test_u16_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_u16_c);
+}
+
+static void test_s24(void)
+{
+	int24_t out[] = { S32_TO_S24(0x000000), S32_TO_S24(0x000000), S32_TO_S24(0x000000) };
+	int24_t in_1[] = { S32_TO_S24(0x000000), S32_TO_S24(0x000000), S32_TO_S24(0x000000) };
+	int24_t in_2[] = { S32_TO_S24(0x7fffff), S32_TO_S24(0xff800000), S32_TO_S24(0x400000) };
+	int24_t in_3[] = { S32_TO_S24(0x400000), S32_TO_S24(0xffc00000), S32_TO_S24(0xffc00000) };
+	int24_t in_4[] = { S32_TO_S24(0xffc00000), S32_TO_S24(0x400000), S32_TO_S24(0x400000) };
+	int24_t out_4[] = { S32_TO_S24(0x7fffff), S32_TO_S24(0xff800000), S32_TO_S24(0x400000) };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_s24_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_s24_c);
+	run_test("test_s24_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_s24_c);
+	run_test("test_s24_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_s24_c);
+}
+
+static void test_u24(void)
+{
+	uint24_t out[] = { U32_TO_U24(0x800000), U32_TO_U24(0x800000), U32_TO_U24(0x800000) };
+	uint24_t in_1[] = { U32_TO_U24(0x800000), U32_TO_U24(0x800000), U32_TO_U24(0x800000) };
+	uint24_t in_2[] = { U32_TO_U24(0xffffffff), U32_TO_U24(0x000000), U32_TO_U24(0xffc00000) };
+	uint24_t in_3[] = { U32_TO_U24(0xffc00000), U32_TO_U24(0x400000), U32_TO_U24(0x400000) };
+	uint24_t in_4[] = { U32_TO_U24(0x400000), U32_TO_U24(0xffc00000), U32_TO_U24(0xffc00000) };
+	uint24_t out_4[] = { U32_TO_U24(0xffffffff), U32_TO_U24(0x000000), U32_TO_U24(0xffc00000) };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_u24_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_u24_c);
+	run_test("test_u24_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_u24_c);
+	run_test("test_u24_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_u24_c);
+}
+
+static void test_s32(void)
+{
+	int32_t out[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000 };
+	int32_t in_1[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000 };
+	int32_t in_2[] = { 0x7fffffff, 0x80000000, 0x40000000, 0xc0000000 };
+	int32_t in_3[] = { 0x40000000, 0xc0000000, 0xc0000000, 0x40000000 };
+	int32_t in_4[] = { 0xc0000000, 0x40000000, 0x40000000, 0xc0000000 };
+	int32_t out_4[] = { 0x7fffffff, 0x80000000, 0x40000000, 0xc0000000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_s32_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_s32_c);
+	run_test("test_s32_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_s32_c);
+	run_test("test_s32_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_s32_c);
+}
+
+static void test_u32(void)
+{
+	uint32_t out[] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
+	uint32_t in_1[] = { 0x80000000, 0x80000000, 0x80000000, 0x80000000 };
+	uint32_t in_2[] = { 0xffffffff, 0x00000000, 0xc0000000, 0x40000000 };
+	uint32_t in_3[] = { 0xc0000000, 0x40000000, 0x40000000, 0xc0000000 };
+	uint32_t in_4[] = { 0x40000000, 0xc0000000, 0xc0000000, 0x40000000 };
+	uint32_t out_4[] = { 0xffffffff, 0x00000000, 0xc0000000, 0x40000000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_u32_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_u32_c);
+	run_test("test_u32_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_u32_c);
+	run_test("test_u32_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_u32_c);
+}
+
+static void test_s24_32(void)
+{
+	int32_t out[] = { 0x000000, 0x000000, 0x000000, 0x000000 };
+	int32_t in_1[] = { 0x000000, 0x000000, 0x000000, 0x000000 };
+	int32_t in_2[] = { 0x7fffff, 0xff800000, 0x400000, 0xffc00000 };
+	int32_t in_3[] = { 0x400000, 0xffc00000, 0xffc00000, 0x400000 };
+	int32_t in_4[] = { 0xffc00000, 0x400000, 0x400000, 0xffc00000 };
+	int32_t out_4[] = { 0x7fffff, 0xff800000, 0x400000, 0xffc00000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_s24_32_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_s24_32_c);
+	run_test("test_s24_32_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_s24_32_c);
+	run_test("test_s24_32_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_s24_32_c);
+}
+
+static void test_u24_32(void)
+{
+	uint32_t out[] = { 0x800000, 0x800000, 0x800000, 0x800000 };
+	uint32_t in_1[] = { 0x800000, 0x800000, 0x800000, 0x800000 };
+	uint32_t in_2[] = { 0xffffff, 0x000000, 0xc00000, 0x400000 };
+	uint32_t in_3[] = { 0xc00000, 0x400000, 0x400000, 0xc00000 };
+	uint32_t in_4[] = { 0x400000, 0xc00000, 0xc00000, 0x400000 };
+	uint32_t out_4[] = { 0xffffff, 0x000000, 0xc00000, 0x400000 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_u24_32_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_u24_32_c);
+	run_test("test_u24_32_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_u24_32_c);
+	run_test("test_u24_32_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_u24_32_c);
+}
+
+static void test_f32(void)
+{
+	float out[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+	float in_1[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+	float in_2[] = { 1.0f, -1.0f, 0.5f, -0.5f };
+	float in_3[] = { 0.5f, -0.5f, -0.5f, 0.5f };
+	float in_4[] = { -0.5f, 1.0f, 0.5f, -0.5f };
+	float out_4[] = { 1.0f, -0.5f, 0.5f, -0.5f };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_f32_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_f32_c);
+	run_test("test_f32_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_f32_c);
+	run_test("test_f32_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_f32_c);
+#if defined(HAVE_SSE)
+	if (cpu_flags & SPA_CPU_FLAG_SSE) {
+		run_test("test_f32_0_sse", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_f32_sse);
+		run_test("test_f32_1_sse", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_f32_sse);
+		run_test("test_f32_4_sse", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_f32_sse);
+	}
+#endif
+#if defined(HAVE_AVX)
+	if (cpu_flags & SPA_CPU_FLAG_AVX) {
+		run_test("test_f32_0_avx", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_f32_avx);
+		run_test("test_f32_1_avx", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_f32_avx);
+		run_test("test_f32_4_avx", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_f32_avx);
+	}
+#endif
+}
+
+static void test_f64(void)
+{
+	double out[] = { 0.0, 0.0, 0.0, 0.0 };
+	double in_1[] = { 0.0, 0.0, 0.0, 0.0 };
+	double in_2[] = { 1.0, -1.0, 0.5, -0.5 };
+	double in_3[] = { 0.5, -0.5, -0.5, 0.5 };
+	double in_4[] = { -0.5, 1.0, 0.5, -0.5 };
+	double out_4[] = { 1.0, -0.5, 0.5, -0.5 };
+	const void *src[6] = { in_1, in_2, in_3, in_4 };
+
+	run_test("test_f64_0", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_f64_c);
+	run_test("test_f64_1", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_f64_c);
+	run_test("test_f64_4", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_f64_c);
+#if defined(HAVE_SSE2)
+	if (cpu_flags & SPA_CPU_FLAG_SSE2) {
+		run_test("test_f64_0_sse2", NULL, 0, out, sizeof(out), SPA_N_ELEMENTS(out), mix_f64_sse2);
+		run_test("test_f64_1_sse2", src, 1, in_1, sizeof(in_1), SPA_N_ELEMENTS(in_1), mix_f64_sse2);
+		run_test("test_f64_4_sse2", src, 4, out_4, sizeof(out_4), SPA_N_ELEMENTS(out_4), mix_f64_sse2);
+	}
+#endif
+}
+
+int main(int argc, char *argv[])
+{
+	cpu_flags = get_cpu_flags();
+	printf("got get CPU flags %d\n", cpu_flags);
+
+	test_s8();
+	test_u8();
+	test_s16();
+	test_u16();
+	test_s24();
+	test_u24();
+	test_s32();
+	test_u32();
+	test_s24_32();
+	test_u24_32();
+	test_f32();
+	test_f64();
+
+	return 0;
+}