audio_sample_format.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "../required.hpp"
#include "../assert.hpp"
#include "../cast.hpp"
#include "../rapid/numeric_array.hpp"
#include <bit>
 
namespace hi::inline v1 {
 
struct audio_sample_format {
    uint8_t num_bytes;
 
    uint8_t num_guard_bits;
 
    uint8_t num_bits;
 
    bool is_float;
 
    std::endian endian;
 
    constexpr audio_sample_format() noexcept :
        num_bytes(0), num_guard_bits(0), num_bits(0), is_float(false), endian(std::endian::native)
    {
    }
 
    constexpr audio_sample_format(audio_sample_format const &) noexcept = default;
    constexpr audio_sample_format(audio_sample_format &&) noexcept = default;
    constexpr audio_sample_format &operator=(audio_sample_format const &) noexcept = default;
    constexpr audio_sample_format &operator=(audio_sample_format &&) noexcept = default;
 
    [[nodiscard]] constexpr audio_sample_format(
        uint8_t num_bytes,
        uint8_t num_guard_bits,
        uint8_t num_bits,
        bool is_float,
        std::endian endian) noexcept :
        num_bytes(num_bytes), num_guard_bits(num_guard_bits), num_bits(num_bits), is_float(is_float), endian(endian)
    {
        hi_axiom(holds_invariant());
    }
 
    [[nodiscard]] static constexpr audio_sample_format float32_le() noexcept
    {
        return {4, 8, 23, true, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format float32_be() noexcept
    {
        return {4, 8, 23, true, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format float32() noexcept
    {
        return {4, 8, 23, true, std::endian::native};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int16_le() noexcept
    {
        return {2, 0, 15, false, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int16_be() noexcept
    {
        return {2, 0, 15, false, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int16() noexcept
    {
        return {2, 0, 15, false, std::endian::native};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int20_le() noexcept
    {
        return {3, 0, 19, false, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int20_be() noexcept
    {
        return {3, 0, 19, false, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int20() noexcept
    {
        return {3, 0, 19, false, std::endian::native};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int24_le() noexcept
    {
        return {3, 0, 23, false, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int24_be() noexcept
    {
        return {3, 0, 23, false, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int24() noexcept
    {
        return {3, 0, 23, false, std::endian::native};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int32_le() noexcept
    {
        return {4, 0, 31, false, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int32_be() noexcept
    {
        return {4, 0, 31, false, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format int32() noexcept
    {
        return {4, 0, 31, false, std::endian::native};
    }
 
    [[nodiscard]] static constexpr audio_sample_format fix8_23_le() noexcept
    {
        return {4, 8, 23, false, std::endian::little};
    }
 
    [[nodiscard]] static constexpr audio_sample_format fix8_23_be() noexcept
    {
        return {4, 8, 23, false, std::endian::big};
    }
 
    [[nodiscard]] static constexpr audio_sample_format fix8_23() noexcept
    {
        return {4, 8, 23, false, std::endian::native};
    }
 
    constexpr explicit operator bool() const noexcept
    {
        return num_bytes != 0;
    }
 
    [[nodiscard]] float pack_multiplier() const noexcept;
 
    [[nodiscard]] float unpack_multiplier() const noexcept;
 
    [[nodiscard]] std::size_t num_samples_per_chunk(std::size_t stride) const noexcept;
 
    [[nodiscard]] std::size_t chunk_stride(std::size_t stride) const noexcept;
 
    [[nodiscard]] std::size_t num_chunks_per_quad(std::size_t stride) const noexcept;
 
    [[nodiscard]] std::size_t num_fast_quads(std::size_t stride, std::size_t num_samples) const noexcept;
 
    [[nodiscard]] i8x16 load_shuffle_indices(std::size_t stride) const noexcept;
 
    [[nodiscard]] i8x16 store_shuffle_indices(std::size_t stride) const noexcept;
 
    [[nodiscard]] i8x16 concat_shuffle_indices(std::size_t stride) const noexcept;
 
    [[nodiscard]] constexpr bool holds_invariant() const noexcept
    {
        return (num_bytes >= 1 && num_bytes <= 4) && (num_bits + num_guard_bits <= num_bytes * 8) &&
            (endian == std::endian::little || endian == std::endian::big);
    }
};
 
} // namespace hi::inline v1