Compiler Explorer

Source code

#include <fmt/core.h>

#include <algorithm>
#include <concepts>
#include <limits>
#include 
#include <type_traits>
#include <vector>
#include <cstdint>

#include <cxxabi.h>
#include <typeinfo>

using std::uint8_t;
using std::uint16_t;
using std::uint32_t;
using std::int8_t;
using std::int16_t;
using std::int32_t;

#define NO_INLINE __attribute__((noinline))

namespace LV
{
 template <typename T, typename U>
 constexpr bool is_same_signedness_v = std::is_signed_v<T> == std::is_signed_v;

template <std::integral T>
 constexpr bool int_promotable_v = sizeof (T) <= sizeof (int);

template <std::integral T>
 constexpr bool is_float_representable_v = std::numeric_limits<T>::digits <= std::numeric_limits<float>::digits;

template <typename T>
 concept integral_sample = std::integral<T> && int_promotable_v<T>;

template <typename T>
 concept signed_integral_sample = std::signed_integral<T> && int_promotable_v<T>;

template <typename T>
 concept unsigned_integral_sample = std::unsigned_integral<T> && int_promotable_v<T>;

// Returns the 'bias' of an unsigned integral type i.e. the offset that can be added to the minimum value of its
 // signed counterpart to get 0.
 // Example: The bias for uint8_t is 128 as the minimum value of an int8_t is -128.
 template <unsigned_integral_sample T>
 constexpr auto bias () -> unsigned int
 {
 return 1U << (std::numeric_limits<T>::digits - 1);
 }

// Converts an integral sample to an unsigned integral sample of the same width.
 // Reduces to an identity function if handed an unsigned integral sample.
 // Example: int16_t and uint16_t samples are both converted to uint16_t.
 template <integral_sample T>
 constexpr auto to_unsigned_sample (T x) -> std::make_unsigned_t<T>
 {
 if constexpr (std::is_signed_v<T>) {
 using U = std::make_unsigned_t<T>;
 return x + bias ();
 } else {
 return x;
 }
 }

// Converts an integral sample to an signed integral sample of the same width.
 // Reduces to an identity function if input is already unsigned.
 // Example: int16_t and uint16_t samples are both converted to uint16_t.
 template <integral_sample T>
 constexpr auto to_signed_sample (T x) -> std::make_signed_t<T>
 {
 if constexpr (!std::is_signed_v<T>) {
 return x - bias<T> ();
 } else {
 return x;
 }
 }

// Converts an integral sample to a narrower or wider integral type with the
 // same signedness.
 //
 // Caveat: Due to the use of shifts for performance instead of float multiplications, the relative error in _widening_
 // conversions can get as large as 0.038 to 0.039% of the true value (e.g. converting from 8-bit to 16/32-bit).
 template <integral_sample T, integral_sample U>
 constexpr auto widen_or_narrow_sample (T x) -> U
 requires is_same_signedness_v<T, U>
 {
 constexpr auto n_t {std::numeric_limits<T>::digits};
 constexpr auto n_u {std::numeric_limits::digits};

if constexpr (n_t > n_u) {
 return x >> (n_t - n_u);
 } else if constexpr (n_t < n_u) {
 return x << (n_u - n_t);
 } else {
 return x;
 }
 }

// Converts an integral sample to 32-bit float.
 template <integral_sample T>
 constexpr auto to_float_sample (T x) -> float
 {
 using U = std::make_unsigned_t<T>;
 using F = std::conditional_t<is_float_representable_v<T>, float, double>;
 
 constexpr F factor = 2.0 / std::numeric_limits::max ();
 constexpr F one = 1.0;

return to_unsigned_sample (x) * factor - one;
  }

// Converts a 32-bit float sample to an integral type.
 template <integral_sample T>
 constexpr auto from_float_sample (float x) -> T
 {
 using U = std::make_unsigned_t<T>;
 using F = std::conditional_t<is_float_representable_v<T>, float, double>;

constexpr F factor = 0.5 * std::numeric_limits::max ();
 constexpr F one = 1.0;

auto y {static_cast ((x + one) * factor)};

if constexpr (std::is_signed_v<T>) {
 return to_signed_sample (y);
 } else {
 return y;
 }
 }

// same format conversion
 template <typename T>
 NO_INLINE
 constexpr void convert_samples (std::span<T> dst, std::span<T const> src)
 {
 auto count {std::min (src.size (), dst.size ())};
 std::memcpy (dst.data (), src.data (), count * sizeof (T));
 }

// signed/unsigned->unsigned int conversion
 template <unsigned_integral_sample D, integral_sample S>
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};
 std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) {
 auto y {to_unsigned_sample (x)};
 return widen_or_narrow_sample<decltype (y), D> (y);
 });
 }

// signed/unsigned->signed int conversion
 template <signed_integral_sample D, integral_sample S>
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};
 std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) {
 auto y {to_signed_sample (x)};
 return widen_or_narrow_sample<decltype (y), D> (y);
 });
 }

// integral->float conversions
 template <integral_sample T>
 NO_INLINE
 constexpr void convert_samples (std::span<float> dst, std::span<T const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};
 std::transform (src.begin (), src.begin () + count, dst.begin (), to_float_sample<T>);
 }

// float->int conversions
 template <integral_sample T>
 NO_INLINE
 constexpr void convert_samples (std::span<T> dst, std::span<float const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};
 std::transform (src.begin (), src.begin () + count, dst.begin (), from_float_sample<T>);
 }

}

namespace LV::Old
{
 template <std::signed_integral T>
 constexpr T half_range ()
 {
 return std::numeric_limits<T>::max ();
 }

template <std::unsigned_integral T>
 constexpr T half_range ()
 {
 return std::numeric_limits<T>::max () / 2 + 1;
 }

template <std::signed_integral T>
 constexpr T zero ()
 {
 return 0;
 }

template <std::unsigned_integral T>
 constexpr T zero ()
 {
 return std::numeric_limits<T>::max () / 2 + 1;
 }

template <typename D, typename S>
 constexpr int shifter()
 {
 if constexpr (sizeof (S) > sizeof (D))
 return int (sizeof (S) - sizeof (D)) << 3;
 else
 return int (sizeof (D) - sizeof (S)) << 3;
 }

// same format conversion
 template <typename T>
 NO_INLINE
 constexpr void convert_samples (std::span<T> dst, std::span<T const> src)
 {
 auto count {std::min (src.size (), dst.size ())};
 std::memcpy (dst.data (), src.data (), count * sizeof (T));
 }

template <std::unsigned_integral D, std::signed_integral S>
 requires (sizeof (D) == sizeof (S))
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {zero<D> ()};
 std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) { return x + a; });
 }

template <std::signed_integral D, std::unsigned_integral S>
 requires (sizeof (D) == sizeof (S))
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};
 constexpr auto a {zero<S> ()};

std::transform (src.begin (), src.begin () + count, dst.begin (),
                        [=] (auto x) { return x - a; });
    }

template <std::integral D, std::integral S>
 requires (is_same_signedness_v<D, S> && sizeof (D) != sizeof (S))
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto shift {shifter<D, S> ()};

std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) {
 if constexpr (sizeof (S) > sizeof (D)) {
 return x >> shift;
 } else {
 return x << shift;
 }
 });
 }

template <std::unsigned_integral D, std::signed_integral S>
 requires (sizeof (D) != sizeof (S))
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {zero<D>()};
 constexpr auto shift {shifter<D, S> ()};

std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) {
 if constexpr (sizeof (D) < sizeof (S)) {
 // narrowing
 return D(x >> shift) + a;
 } else {
 // widening
 return D(x << shift) + a;
 }
 });
 }

template <std::signed_integral D, std::unsigned_integral S>
 requires (sizeof (D) != sizeof (S))
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {zero<D>()};
 constexpr auto shift {shifter<D, S> ()};

std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) {
 if constexpr (sizeof (D) < sizeof (S)) {
 // narrowing
 return D(x >> shift) - a;
 } else {
 // widening
 return D(x << shift) - a;
 }
 });
 }

template <std::unsigned_integral D, std::signed_integral S>
 requires (sizeof (D) == sizeof (S))
 NO_INLINE
 constexpr void convert_sample_array (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {zero<D> ()};
 std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) { return x + a; });
 }

template <std::signed_integral D, std::unsigned_integral S>
 requires (sizeof (D) == sizeof (S))
 NO_INLINE
 constexpr void convert_sample_array (std::span<D> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {zero<S> ()};
 std::transform (src.begin (), src.begin () + count, dst.begin (),
 [=] (auto x) { return x - a; });
 }

template <std::integral S>
 NO_INLINE
 constexpr void convert_samples (std::span<float> dst, std::span<S const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr float a {1.0 / float (half_range<S> ())};
 constexpr float b {zero<S> () * a};

std::transform (src.begin (), src.begin () + count, dst.begin (),
                        [=] (auto x) {
                            return x * a - b;
                        });
    }

template <std::integral D>
 NO_INLINE
 constexpr void convert_samples (std::span<D> dst, std::span<float const> src)
 {
 const auto count {std::min (src.size (), dst.size ())};

constexpr auto a {float (half_range<D> ())};
 constexpr auto b {zero<D> ()};

std::transform (src.begin (), src.begin () + count, dst.begin (),
                        [=] (auto x) {
                            return x * a + b;
                        });
    }
}

namespace LV::C {

#define TRUE  1
    #define FALSE 0

struct VisBuffer
    {
        void *data;
        std::size_t datasize;
    };

void* visual_buffer_get_data (VisBuffer *buffer)
    {
        return buffer->data;
    }

std::size_t visual_buffer_get_size (VisBuffer *buffer)
    {
        return buffer->datasize;
    }

int visual_buffer_put_data (VisBuffer *dest, void *data, std::size_t size, int byteoffset)
    {
        int amount;

amount = size;

if (byteoffset + size > dest->datasize)
            amount = dest->datasize - byteoffset;

std::memcpy ((std::byte *) dest->data + byteoffset, data, amount);

return 0;
    }

int visual_buffer_put (VisBuffer *dest, VisBuffer *src, int byteoffset)
    {
    	return visual_buffer_put_data (dest, src->data, src->datasize, byteoffset);
    }

// BUG: Overflows if bytes == 4 (for uint32_t and int32_t)
    static int byte_max_numeric (int bytes)
    {
        int result = 256;
        int i;

if (bytes == 0)
            return 0;

for (i = 1; i < bytes; i++)
 result *= 256;

return result;
    }

/* FIXME use lv_math acceleration here! */
 // Fix: src substituted with dest
 #define FORMAT_BUFFER_FROM_FLOAT(a,b)						\
 {													 \
 if (sign) {											\
 a *dbuf = (a *)visual_buffer_get_data (dest);	\
 for (i = 0; i < entries; i++) {					\
 dbuf[i] = sbuf[i] * signedcorr;				\
 }											 \
 } else {											\
 b *dbuf = (b *)visual_buffer_get_data (dest); \
 for (i = 0; i < entries; i++) {					\
 dbuf[i] = (sbuf[i] * signedcorr) + signedcorr; \
 }											\
 }												\
 }

static int transform_format_buffer_from_float (VisBuffer *dest, VisBuffer *src, int size, int sign)
    {
        float *sbuf = (float *) visual_buffer_get_data (src);
        int entries = visual_buffer_get_size (dest) / size;
        int signedcorr;
        int i;

signedcorr = byte_max_numeric (size) / 2;

if (size == 1)
            FORMAT_BUFFER_FROM_FLOAT(int8_t, uint8_t)
        else if (size == 2)
            FORMAT_BUFFER_FROM_FLOAT(int16_t, uint16_t)
        else if (size == 4)
            FORMAT_BUFFER_FROM_FLOAT(int32_t, uint32_t)

return 0;
    }

#define FORMAT_BUFFER_TO_FLOAT(a,b)							 \
 {													 \
 float multiplier = 1.0 / signedcorr;				 \
 if (sign) {											 \
 a *sbuf = (a *) visual_buffer_get_data (src);	 \
 for (i = 0; i < entries; i++) {					 \
 dbuf[i] = sbuf[i] * multiplier;				 \
 }											 \
 } else {											 \
 b *sbuf = (b *) visual_buffer_get_data (src);	 \
 for (i = 0; i < entries; i++) {					 \
 dbuf[i] = (sbuf[i] - signedcorr) * multiplier; \
 }											 \
 }												 \
 }

static int transform_format_buffer_to_float (VisBuffer *dest, VisBuffer *src, int size, int sign)
    {
        float *dbuf = (float *) visual_buffer_get_data (dest);
        int entries = visual_buffer_get_size (dest) / sizeof (float);
        int signedcorr;
        int i;

signedcorr = byte_max_numeric (size) / 2;

if (size == 1)
            FORMAT_BUFFER_TO_FLOAT(int8_t, uint8_t)
        else if (size == 2)
            FORMAT_BUFFER_TO_FLOAT(int16_t, uint16_t)
        else if (size == 4)
            FORMAT_BUFFER_TO_FLOAT(int32_t, uint32_t)

return 0;
    }

#define FORMAT_BUFFER(a,b,c,d)										\
 {												 \
 if (signedcorr == 0) {									\
 visual_buffer_put (dest, src, 0);					\
 } else {										 \
 if (signedcorr < 0) {								\
 a *dbuf = (a *) visual_buffer_get_data (dest);	\
 b *sbuf = (b *) visual_buffer_get_data (src);	\
 for (i = 0; i < entries; i++) {					\
 dbuf[i] = sbuf[i] + signedcorr;				\
 }									 \
 } else {									 \
 c *dbuf = (c *) visual_buffer_get_data (dest);	\
 d *sbuf = (d *) visual_buffer_get_data (src);	\
 for (i = 0; i < entries; i++) {					\
 dbuf[i] = sbuf[i] + signedcorr;				\
 }									 \
 }										 \
 }											 \
 }

#define FORMAT_BUFFER_INCREASE(a,b,c,d)								\
 {												 \
 if (signedcorr < 0) {									\
 a *dbuf = (a *) visual_buffer_get_data (dest);		\
 b *sbuf = (b *) visual_buffer_get_data (src);		\
 for (i = 0; i < entries; i++) {						\
 dbuf[i] = (sbuf[i] << shifter) + signedcorr;	\
 }										 \
 } else {										 \
 c *dbuf = (c *) visual_buffer_get_data (dest);		\
 d *sbuf = (d *) visual_buffer_get_data (src);		\
 for (i = 0; i < entries; i++) {						\
 dbuf[i] = (sbuf[i] << shifter) + signedcorr;	\
 }										 \
 }											 \
 }

#define FORMAT_BUFFER_DECREASE(a,b,c,d)								\
 {												 \
 if (signedcorr < 0) {									\
 a *dbuf = (a *) visual_buffer_get_data (dest);		\
 b *sbuf = (b *) visual_buffer_get_data (src);		\
 for (i = 0; i < entries; i++) {						\
 dbuf[i] = (sbuf[i] >> shifter) + signedcorr;	\
 }										 \
 } else {										 \
 c *dbuf = (c *) visual_buffer_get_data (dest);		\
 d *sbuf = (d *) visual_buffer_get_data (src);		\
 for (i = 0; i < entries; i++) {						\
 dbuf[i] = (sbuf[i] >> shifter) + signedcorr;	\
 }										 \
 }											 \
 }

static int transform_format_buffer (VisBuffer *dest, VisBuffer *src, int dsize, int ssize, int dsigned, int ssigned)
    {
        int signedcorr = 0;
        int entries = visual_buffer_get_size (dest) / dsize;
        int shifter = 0;
        int i;

if (dsigned == TRUE && ssigned == FALSE)
            signedcorr -= byte_max_numeric (ssize) / 2;
        else if (dsigned == FALSE && ssigned == TRUE)
            signedcorr += byte_max_numeric (dsize) / 2;

if (dsize > ssize)
 shifter = (dsize - ssize); // BUG: shifter is in bits while ssize/dsize are in bytes;
 else if (dsize < ssize)
 shifter = (ssize - dsize); // BUG: shifter is in bits while ssize/dsize are in bytes;

/* FIXME simd versions of every conversion */
        if (dsize == 1 && ssize == 1)		/* 8 to 8 */
            FORMAT_BUFFER(int8_t, uint8_t, uint8_t, int8_t)
        else if (dsize == 2 && ssize == 1)	/* 8 to 16 */
            FORMAT_BUFFER_INCREASE(int16_t, int8_t, uint16_t, uint8_t)
        else if (dsize == 4 && ssize == 1)	/* 8 to 32 */
            FORMAT_BUFFER_INCREASE(int32_t, int8_t, uint32_t, uint8_t)
        else if (dsize == 2 && ssize == 2)	/* 16 to 16 */
            FORMAT_BUFFER(int16_t, uint16_t, uint16_t, int16_t)
        else if (dsize == 4 && ssize == 2)	/* 32 to 16 */
            FORMAT_BUFFER_INCREASE(int32_t, int16_t, uint32_t, uint16_t)
        else if (dsize == 4 && ssize == 4)	/* 32 to 32 */
            FORMAT_BUFFER(int32_t, uint32_t, uint32_t, int32_t)
        else if (dsize == 1 && ssize == 2)	/* 16 to 8 */
            FORMAT_BUFFER_DECREASE(int8_t, int16_t, uint8_t, uint16_t)
        else if (dsize == 2 && ssize == 4)	/* 32 to 16 */
            FORMAT_BUFFER_DECREASE(int16_t, int32_t, uint16_t, uint32_t)
        else if (dsize == 1 && ssize == 4)	/* 32 to 8 */
            FORMAT_BUFFER_DECREASE(int8_t, int32_t, uint8_t, uint32_t)

return 0;
    }

template <typename D, typename S>
 void convert_samples (std::span<D> dest, std::span<S const> src)
 {
 VisBuffer dest_buffer = {
 .data = dest.data (),
 .datasize = dest.size () * sizeof (D)
 };

VisBuffer src_buffer = {
 .data = const_cast<S*> (src.data ()),
 .datasize = src.size () * sizeof (S)
 };

int dsize = sizeof(D);
 int ssize = sizeof(S);
 int dsigned = std::is_signed_v<D>;
 int ssigned = std::is_signed_v<S>;

if constexpr (std::is_same_v<D, float>) {
 transform_format_buffer_from_float (&dest_buffer, &src_buffer, ssize, ssigned); // BUG: to_float, not from_float!
 } else if constexpr (std::is_same_v<S, float>) {
 transform_format_buffer_to_float (&dest_buffer, &src_buffer, dsize, dsigned); // BUG: from_float, not to_float!
 } else if constexpr (std::is_same_v<S, float> && std::is_same_v<D, float>) {
 visual_buffer_put (&dest_buffer, &src_buffer, 0);
 } else {
 transform_format_buffer (&dest_buffer, &src_buffer, dsize, ssize, dsigned, ssigned);
 }
 }
}

#define RUN_TEST(s, d, src) { \
 fmt::print (#s " -> " #d "\n"); \
 run_test<s, d> (src); \
}

namespace
{
 template <std::integral T>
 constexpr T sample_min ()
 {
 return std::numeric_limits<T>::min ();
 }

template <std::floating_point T>
 constexpr T sample_min ()
 {
 return T {-1.0};
 }

template <std::integral T>
 constexpr T sample_max ()
 {
 return std::numeric_limits<T>::max ();
 }

template <std::floating_point T>
 constexpr T sample_max ()
 {
 return T {1.0};
 }

template <typename S, typename D>
 void run_test (std::vector<S> const& src)
 {
 std::vector<D> dst1 (src.size ());
 std::vector<D> dst2 (src.size ());
 std::vector<D> dst3 (src.size ());

std::span in {src};
        std::span out1 {dst1};
        std::span out2 {dst2};
        std::span out3 {dst3};

LV::convert_samples (out1, in);
        LV::Old::convert_samples (out2, in);
        LV::C::convert_samples (out3, in);

fmt::print ("[{}, {}] -> [{}, {}]\n", sample_min<S> (), sample_max<S> (), sample_min<D> (), sample_max<D> ());

for (unsigned int i {0}; i < in.size (); i++) {
 fmt::print ("{:>11} -> {:>11} vs {:>11} vs {:>11}\n", in[i], out1[i], out2[i], out3[i]);
 }
 fmt::print("\n");
 }

template <std::integral T>
 constexpr auto generate_samples (int count) -> std::vector<T>
 {
 constexpr auto min {std::numeric_limits<T>::min()};
 constexpr auto max {std::numeric_limits<T>::max()};

const auto f {(static_cast<double> (max) - min) / (count - 1)};

std::vector<T> values;
 values.reserve(count);

for (int i = 0; i < count; i++) {
 values.emplace_back(static_cast<T>(min + i * f));
 }

return values;
    }

constexpr auto generate_float_samples (int count) -> std::vector<float>
 {
 std::vector<float> values;
 values.reserve(count);

for (int i = 0; i < count; i++) {
 values.emplace_back (static_cast<float>(-1.0 + static_cast<double> (i) / (count-1) * 2.0));
 }

return values;
    }
}

int main ()
{
 const auto u8_samples {generate_samples<uint8_t> (8)};
 const auto s8_samples {generate_samples<int8_t> (8)};
 const auto u16_samples {generate_samples<uint16_t> (8)};
 const auto s16_samples {generate_samples<int16_t> (8)};
 const auto u32_samples {generate_samples<uint32_t> (8)};
 const auto s32_samples {generate_samples<int32_t> (8)};
 const auto f32_samples {generate_float_samples (8)};

RUN_TEST(int8_t, uint8_t, s8_samples);
    RUN_TEST(int8_t, int8_t, s8_samples);
    RUN_TEST(int8_t, uint16_t, s8_samples);
    RUN_TEST(int8_t, int16_t, s8_samples);
    RUN_TEST(int8_t, uint32_t, s8_samples);
    RUN_TEST(int8_t, int32_t, s8_samples);
    RUN_TEST(int8_t, float, s8_samples);
    
    RUN_TEST(uint8_t, uint8_t, u8_samples);
    RUN_TEST(uint8_t, int8_t, u8_samples);
    RUN_TEST(uint8_t, uint16_t, u8_samples);
    RUN_TEST(uint8_t, int16_t, u8_samples);
    RUN_TEST(uint8_t, uint32_t, u8_samples);
    RUN_TEST(uint8_t, int32_t, u8_samples);
    RUN_TEST(uint8_t, float, u8_samples);

RUN_TEST(int16_t, int8_t, s16_samples);
    RUN_TEST(int16_t, uint8_t, s16_samples);
    RUN_TEST(int16_t, uint16_t, s16_samples);
    RUN_TEST(int16_t, int16_t, s16_samples);
    RUN_TEST(int16_t, uint32_t, s16_samples);
    RUN_TEST(int16_t, int32_t, s16_samples);
    RUN_TEST(int16_t, float, s16_samples);

RUN_TEST(uint16_t, uint8_t, u16_samples);
    RUN_TEST(uint16_t, int8_t, u16_samples);
    RUN_TEST(uint16_t, uint16_t, u16_samples);
    RUN_TEST(uint16_t, int16_t, u16_samples);
    RUN_TEST(uint16_t, uint32_t, u16_samples);
    RUN_TEST(uint16_t, int32_t, u16_samples);
    RUN_TEST(uint16_t, float, u16_samples);

RUN_TEST(int32_t, uint8_t, s32_samples);
    RUN_TEST(int32_t, int8_t, s32_samples);
    RUN_TEST(int32_t, uint16_t, s32_samples);
    RUN_TEST(int32_t, int16_t, s32_samples);
    RUN_TEST(int32_t, uint32_t, s32_samples);
    RUN_TEST(int32_t, int32_t, s32_samples);
    RUN_TEST(int32_t, float, s32_samples);

RUN_TEST(uint32_t, uint8_t, u32_samples);
    RUN_TEST(uint32_t, int8_t, u32_samples);
    RUN_TEST(uint32_t, uint16_t, u32_samples);
    RUN_TEST(uint32_t, int16_t, u32_samples);
    RUN_TEST(uint32_t, uint32_t, u32_samples);
    RUN_TEST(uint32_t, int32_t, u32_samples);
    RUN_TEST(uint32_t, float, u32_samples);

RUN_TEST(float, uint8_t, f32_samples);
    RUN_TEST(float, int8_t, f32_samples);
    RUN_TEST(float, uint16_t, f32_samples);
    RUN_TEST(float, int16_t, f32_samples);
    RUN_TEST(float, int32_t, f32_samples);
    RUN_TEST(float, uint32_t, f32_samples);
    RUN_TEST(float, float, f32_samples);
}