text stringlengths 1 24.5M |
|---|
#ifndef BACKENDS_PORTAUDIO_HPP
#define BACKENDS_PORTAUDIO_HPP
#include "base.h"
struct PortBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto cr... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2009 by Konstantinos Natsakis <konstantinos.natsakis@gmail.com>
* Copyright (C) 2010 by Chris Robinson <chris.kcat@gmail.com>
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* ... |
#ifndef BACKENDS_PULSEAUDIO_H
#define BACKENDS_PULSEAUDIO_H
#include <string>
#include <vector>
#include "alc/events.h"
#include "base.h"
struct DeviceBase;
class PulseBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
a... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2018 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option)... |
#ifndef BACKENDS_SDL2_H
#define BACKENDS_SDL2_H
#include "base.h"
struct SDL2BackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createBackend(De... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2024 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option)... |
#ifndef BACKENDS_SDL3_H
#define BACKENDS_SDL3_H
#include "base.h"
struct SDL3BackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createBackend(De... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef BACKENDS_SNDIO_HPP
#define BACKENDS_SNDIO_HPP
#include "base.h"
struct SndIOBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createBac... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef BACKENDS_SOLARIS_H
#define BACKENDS_SOLARIS_H
#include "base.h"
struct SolarisBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createB... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2011 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option)... |
#ifndef BACKENDS_WASAPI_H
#define BACKENDS_WASAPI_H
#include "base.h"
struct WasapiBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto queryEventSupport(alc::EventType eventType, BackendType type) -> alc::EventSupport ... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef BACKENDS_WAVE_H
#define BACKENDS_WAVE_H
#include "base.h"
struct WaveBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createBackend(De... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef BACKENDS_WINMM_H
#define BACKENDS_WINMM_H
#include "base.h"
struct WinMMBackendFactory final : public BackendFactory {
public:
auto init() -> bool final;
auto querySupport(BackendType type) -> bool final;
auto enumerate(BackendType type) -> std::vector<std::string> final;
auto createBackend... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2018 by Raul Herraiz.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef EFFECTS_BASE_H
#define EFFECTS_BASE_H
#include "core/effects/base.h"
/* This is a user config option for modifying the overall output of the reverb
* effect.
*/
inline float ReverbBoost{1.0f};
EffectStateFactory *NullStateFactory_getFactory();
EffectStateFactory *ReverbStateFactory_getFactory();
EffectSt... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2013 by Mike Gorchak
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your opt... |
/**
* This file is part of the OpenAL Soft cross platform audio library
*
* Copyright (C) 2013 by Anis A. Hireche
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain ... |
#include "config.h"
#include "config_simd.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <vector>
#if HAVE_SSE_INTRINSICS
#include <xmmintrin.h>
#elif HAVE_NEON
#include <arm_neon.h... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2011 by Chris Robinson.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your ... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2013 by Mike Gorchak
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your opt... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2009 by Chris Robinson.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your ... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2013 by Mike Gorchak
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your opt... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2018 by Raul Herraiz.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2009 by Chris Robinson.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your ... |
#include "config.h"
#include <cstddef>
#include "alspan.h"
#include "base.h"
#include "core/bufferline.h"
#include "core/effects/base.h"
#include "intrusive_ptr.h"
struct BufferStorage;
struct ContextBase;
struct DeviceBase;
struct EffectSlot;
namespace {
struct NullState final : public EffectState {
NullSta... |
/**
* OpenAL cross platform audio library
* Copyright (C) 2018 by Raul Herraiz.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
/**
* Ambisonic reverb engine for the OpenAL cross platform audio library
* Copyright (C) 2008-2017 by Chris Robinson and Christopher Fitzgerald.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Softwa... |
/**
* This file is part of the OpenAL Soft cross platform audio library
*
* Copyright (C) 2019 by Anis A. Hireche
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain ... |
#include "alassert.h"
#include <stdexcept>
#include <string>
namespace {
[[noreturn]]
void throw_error(const std::string &message)
{
throw std::runtime_error{message};
}
} /* namespace */
namespace al {
[[noreturn]]
void do_assert(const char *message, int linenum, const char *filename, const char *funcname) ... |
#ifndef AL_ASSERT_H
#define AL_ASSERT_H
#include <array>
#include "opthelpers.h"
namespace al {
[[noreturn]]
void do_assert(const char *message, int linenum, const char *filename, const char *funcname) noexcept;
} /* namespace al */
/* A custom assert macro that is not compiled out for Release/NDEBUG builds,
* m... |
#ifndef AL_BIT_H
#define AL_BIT_H
#include <algorithm>
#include <array>
#ifndef __GNUC__
#include <cstdint>
#endif
#include <cstring>
#include <limits>
#include <new>
#include <type_traits>
#if !defined(__GNUC__) && (defined(_WIN32) || defined(_WIN64))
#include <intrin.h>
#endif
namespace al {
template<typename To, ... |
#include "config.h"
#include "alcomplex.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <functional>
#include <iterator>
#include <utility>
#include "albit.h"
#include "alnumbers.h"
#include "alnumeric.h"
#include "opthelpers.h"
namespace {
using ushort = unsigned short;
u... |
#ifndef ALCOMPLEX_H
#define ALCOMPLEX_H
#include <complex>
#include "alspan.h"
/**
* Iterative implementation of 2-radix FFT (In-place algorithm). Sign = -1 is
* FFT and 1 is inverse FFT. Applies the Discrete Fourier Transform (DFT) to
* the data supplied in the buffer, which MUST BE power of two.
*/
void comple... |
#ifndef AL_MALLOC_H
#define AL_MALLOC_H
#include <algorithm>
#include <cstddef>
#include <limits>
#include <new>
#include <type_traits>
#include <utility>
#include <variant>
namespace gsl {
template<typename T> using owner = T;
}
#define DISABLE_ALLOC \
v... |
#ifndef COMMON_ALNUMBERS_H
#define COMMON_ALNUMBERS_H
#include <type_traits>
namespace al::numbers {
namespace detail_ {
template<typename T>
using as_fp = std::enable_if_t<std::is_floating_point<T>::value, T>;
} // detail_
template<typename T>
inline constexpr auto pi_v = detail_::as_fp<T>(3.14159265358979... |
#ifndef AL_NUMERIC_H
#define AL_NUMERIC_H
#include "config_simd.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <type_traits>
#ifdef HAVE_INTRIN_H
#include <intrin.h>
#endif
#if HAVE_SSE_INTRINSICS
#include <xmmintrin.h>
#endif
#include ... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef COMMON_ALSEM_H
#define COMMON_ALSEM_H
#if defined(__APPLE__)
#include <AvailabilityMacros.h>
#include <TargetConditionals.h>
#if (((MAC_OS_X_VERSION_MIN_REQUIRED > 1050) && !defined(__ppc__)) || TARGET_OS_IOS || TARGET_OS_TV)
#include <dispatch/dispatch.h>
#define AL_APPLE_HAVE_DISPATCH 1
#else
#include <semap... |
#ifndef AL_SPAN_H
#define AL_SPAN_H
#include <cassert>
#include <cstddef>
#include <iterator>
#include <stdexcept>
#include <tuple>
#include <type_traits>
#include <utility>
#include "alassert.h"
#include "almalloc.h"
#include "altraits.h"
namespace al {
/* This is here primarily to help ensure proper behavior for ... |
#include "config.h"
#include "alstring.h"
#include <algorithm>
#include <cctype>
#include <cwctype>
#include <cstring>
namespace al {
int case_compare(const std::string_view str0, const std::string_view str1) noexcept
{
using Traits = std::string_view::traits_type;
auto ch0 = str0.cbegin();
auto ch1 ... |
#ifndef AL_STRING_H
#define AL_STRING_H
#include <algorithm>
#include <cstddef>
#include <limits>
#include <string>
#include <string_view>
namespace al {
template<typename ...Ts>
[[nodiscard]] constexpr
auto sizei(const std::basic_string_view<Ts...> str) noexcept -> int
{ return static_cast<int>(std::min<std::size_... |
#include "config.h"
#include "althrd_setname.h"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
void althrd_setname(const char *name [[maybe_unused]])
{
#if defined(_MSC_VER) && !defined(_M_ARM)
#define MS_VC_EXCEPTION 0x406D1388
#pragma pack(push,8)
struct InfoStruct {
DWORD dwType; ... |
#ifndef COMMON_ALTHRD_SETNAME_H
#define COMMON_ALTHRD_SETNAME_H
void althrd_setname(const char *name);
#endif /* COMMON_ALTHRD_SETNAME_H */
|
#ifndef AL_THREADS_H
#define AL_THREADS_H
#include <cstdint>
#include <stdexcept>
#include <type_traits>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#elif defined(__STDC_NO_THREADS__) || !__has_include(<threads.h>)
#include <pthread.h>
#else
#include <threads.h>
#endif
#include "albit.h"
name... |
#ifndef COMMON_ALTRAITS_H
#define COMMON_ALTRAITS_H
namespace al {
template<typename T>
struct type_identity { using type = T; };
template<typename T>
using type_identity_t = typename type_identity<T>::type;
} // namespace al
#endif /* COMMON_ALTRAITS_H */
|
#ifndef AL_ATOMIC_H
#define AL_ATOMIC_H
#include <atomic>
#include <cstddef>
#include <memory>
#include "almalloc.h"
template<typename T>
auto IncrementRef(std::atomic<T> &ref) noexcept
{ return ref.fetch_add(1u, std::memory_order_acq_rel)+1u; }
template<typename T>
auto DecrementRef(std::atomic<T> &ref) noexcept
{... |
#ifndef COMMON_COMPTR_H
#define COMMON_COMPTR_H
#ifdef _WIN32
#include <cstddef>
#include <utility>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <objbase.h>
struct ComWrapper {
HRESULT mStatus{};
ComWrapper(void *reserved, DWORD coinit)
: mStatus{CoInitializeEx(reserved, coinit)}
{ ... |
#include "config.h"
#include "dynload.h"
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "strutils.h"
void *LoadLib(const char *name)
{
std::wstring wname{utf8_to_wstr(name)};
return LoadLibraryW(wname.c_str());
}
void CloseLib(void *handle)
{ FreeLibrary(static_cast<HMODULE>(handle... |
#ifndef AL_DYNLOAD_H
#define AL_DYNLOAD_H
#if defined(_WIN32) || defined(HAVE_DLFCN_H)
#define HAVE_DYNLOAD 1
void *LoadLib(const char *name);
void CloseLib(void *handle);
void *GetSymbol(void *handle, const char *name);
#else
#define HAVE_DYNLOAD 0
#endif
#endif /* AL_DYNLOAD_H */
|
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@p... |
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s.schuemann@p... |
#ifndef AL_FLEXARRAY_H
#define AL_FLEXARRAY_H
#include <algorithm>
#include <cstddef>
#include <iterator>
#include <memory>
#include <new>
#include <type_traits>
#include "almalloc.h"
#include "alspan.h"
namespace al {
/* Storage for flexible array data. This is trivially destructible if type T is
* trivially dest... |
//---------------------------------------------------------------------------------------
//
// ghc::filesystem - A C++17-like filesystem implementation for C++11/C++14/C++17/C++20
//
//---------------------------------------------------------------------------------------
//
// Copyright (c) 2018, Steffen Schümann <s... |
#ifndef INTRUSIVE_PTR_H
#define INTRUSIVE_PTR_H
#include <atomic>
#include <cstddef>
#include <utility>
#include "atomic.h"
#include "opthelpers.h"
namespace al {
template<typename T>
class intrusive_ref {
std::atomic<unsigned int> mRef{1u};
protected:
~intrusive_ref() = default;
public:
unsigned int... |
#ifndef OPTHELPERS_H
#define OPTHELPERS_H
#include <cstdint>
#include <utility>
#include <memory>
#ifdef __has_builtin
#define HAS_BUILTIN __has_builtin
#else
#define HAS_BUILTIN(x) (0)
#endif
#ifdef __has_cpp_attribute
#define HAS_ATTRIBUTE __has_cpp_attribute
#else
#define HAS_ATTRIBUTE(x) (0)
#endif
#ifdef __GNU... |
//$ nobt
/* Copyright (c) 2013 Julien Pommier ( pommier@modartt.com )
* Copyright (c) 2023 Christopher Robinson
*
* Based on original fortran 77 code from FFTPACKv4 from NETLIB
* (http://www.netlib.org/fftpack), authored by Dr Paul Swarztrauber
* of NCAR, in 1985.
*
* As confirmed by the NCAR fftpack software... |
/* Copyright (c) 2013 Julien Pommier ( pommier@modartt.com )
Based on original fortran 77 code from FFTPACKv4 from NETLIB,
authored by Dr Paul Swarztrauber of NCAR, in 1985.
As confirmed by the NCAR fftpack software curators, the following
FFTPACKv5 license applies to FFTPACKv4 sources. My changes are
... |
#ifndef PHASE_SHIFTER_H
#define PHASE_SHIFTER_H
#include "config_simd.h"
#if HAVE_SSE_INTRINSICS
#include <xmmintrin.h>
#elif HAVE_NEON
#include <arm_neon.h>
#endif
#include <array>
#include <cmath>
#include <cstddef>
#include "alnumbers.h"
#include "alspan.h"
#include "opthelpers.h"
/* Implements a wide-band +90... |
#include "polyphase_resampler.h"
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <numeric>
#include <tuple>
#include "alnumbers.h"
#include "opthelpers.h"
using uint = unsigned int;
namespace {
constexpr double Epsilon{1e-9};
/* The zero-order modified Bessel function of the first kind, used ... |
#ifndef POLYPHASE_RESAMPLER_H
#define POLYPHASE_RESAMPLER_H
#include <vector>
#include "alspan.h"
using uint = unsigned int;
/* This is a polyphase sinc-filtered resampler. It is built for very high
* quality results, rather than real-time performance.
*
* Upsample Downsample
... |
#ifndef PRAGMADEFS_H
#define PRAGMADEFS_H
#if defined(_MSC_VER)
#define DIAGNOSTIC_PUSH __pragma(warning(push))
#define DIAGNOSTIC_POP __pragma(warning(pop))
#define std_pragma(...)
#define msc_pragma __pragma
#else
#if defined(__GNUC__) || defined(__clang__)
#define DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
#def... |
/**
* OpenAL cross platform audio library
* Copyright (C) 1999-2007 by authors.
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your op... |
#ifndef RINGBUFFER_H
#define RINGBUFFER_H
#include <atomic>
#include <cassert>
#include <cstddef>
#include <memory>
#include <utility>
#include "almalloc.h"
#include "flexarray.h"
/* NOTE: This lockless ringbuffer implementation is copied from JACK, extended
* to include an element size. Consequently, parameters a... |
#include "config.h"
#include "strutils.h"
#include <cstdlib>
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "alstring.h"
/* NOLINTBEGIN(bugprone-suspicious-stringview-data-usage) */
std::string wstr_to_utf8(std::wstring_view wstr)
{
std::string ret;
const int len{WideCharToMultiB... |
#ifndef AL_STRUTILS_H
#define AL_STRUTILS_H
#include <optional>
#include <string>
#ifdef _WIN32
#include <cwchar>
#include <string_view>
std::string wstr_to_utf8(std::wstring_view wstr);
std::wstring utf8_to_wstr(std::string_view str);
#endif
namespace al {
std::optional<std::string> getenv(const char *envname);
#... |
#ifndef COMMON_VECMAT_H
#define COMMON_VECMAT_H
#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <limits>
#include "alspan.h"
namespace alu {
class Vector {
alignas(16) std::array<float,4> mVals{};
public:
constexpr Vector() noexcept = default;
constexpr Vector(const ... |
#ifndef AL_VECTOR_H
#define AL_VECTOR_H
#include <cstddef>
#include <vector>
#include "almalloc.h"
namespace al {
template<typename T, std::size_t alignment=alignof(T)>
using vector = std::vector<T, al::allocator<T, alignment>>;
} // namespace al
#endif /* AL_VECTOR_H */
|
#ifndef WIN_MAIN_UTF8_H
#define WIN_MAIN_UTF8_H
/* For Windows systems this provides a way to get UTF-8 encoded argv strings,
* and also overrides fopen to accept UTF-8 filenames. Working with wmain
* directly complicates cross-platform compatibility, while normal main() in
* Windows uses the current codepage (whic... |
#include "config.h"
#include "ambdec.h"
#include <algorithm>
#include <cctype>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <fstream>
#include <iterator>
#include <sstream>
#include <string>
#include "albit.h"
#include "alspan.h"
#include "filesystem.h"
#include "fmt/core.h"
namespace {
std::... |
#ifndef CORE_AMBDEC_H
#define CORE_AMBDEC_H
#include <array>
#include <memory>
#include <optional>
#include <string>
#include <vector>
#include "alspan.h"
#include "core/ambidefs.h"
/* Helpers to read .ambdec configuration files. */
enum class AmbDecScale {
Unset,
N3D,
SN3D,
FuMa,
};
struct AmbDecCo... |
#include "config.h"
#include "ambidefs.h"
#include "alnumbers.h"
namespace {
using AmbiChannelFloatArray = std::array<float,MaxAmbiChannels>;
constexpr auto inv_sqrt3f = static_cast<float>(1.0/al::numbers::sqrt3);
/* These HF gains are derived from the same 32-point speaker array. The scale
* factor between o... |
#ifndef CORE_AMBIDEFS_H
#define CORE_AMBIDEFS_H
#include <array>
#include <cstddef>
#include <cstdint>
#include "alnumbers.h"
using uint = unsigned int;
/* The maximum number of Ambisonics channels. For a given order (o), the size
* needed will be (o+1)**2, thus zero-order has 1, first-order has 4, second-
* ord... |
#ifndef CORE_EVENT_H
#define CORE_EVENT_H
#include <array>
#include <cstdint>
#include <string>
#include <variant>
#include "almalloc.h"
struct EffectState;
using uint = unsigned int;
enum class AsyncEnableBits : std::uint8_t {
SourceState,
BufferCompleted,
Disconnected,
Count
};
enum class Asyn... |
#include "config.h"
#include "bformatdec.h"
#include <algorithm>
#include <array>
#include <cmath>
#include <functional>
#include <utility>
#include "alnumbers.h"
#include "bufferline.h"
#include "filters/splitter.h"
#include "flexarray.h"
#include "front_stablizer.h"
#include "mixer.h"
#include "opthelpers.h"
na... |
#ifndef CORE_BFORMATDEC_H
#define CORE_BFORMATDEC_H
#include <array>
#include <cstddef>
#include <memory>
#include <variant>
#include <vector>
#include "alspan.h"
#include "ambidefs.h"
#include "bufferline.h"
#include "devformat.h"
#include "filters/splitter.h"
#include "front_stablizer.h"
#include "opthelpers.h"
u... |
/*-
* Copyright (c) 2005 Boris Mikhaylov
*
* 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, pu... |
/*-
* Copyright (c) 2005 Boris Mikhaylov
*
* 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, pu... |
#ifndef CORE_BSINC_DEFS_H
#define CORE_BSINC_DEFS_H
/* The number of distinct scale and phase intervals within the bsinc filter
* tables.
*/
constexpr unsigned int BSincScaleBits{4};
constexpr unsigned int BSincScaleCount{1 << BSincScaleBits};
constexpr unsigned int BSincPhaseBits{5};
constexpr unsigned int BSincPha... |
#include "bsinc_tables.h"
#include <algorithm>
#include <array>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <limits>
#include <stdexcept>
#include <vector>
#include "alnumbers.h"
#include "alnumeric.h"
#include "alspan.h"
#include "bsinc_defs.h"
#include "opthelpers.h"
#include "resampler_limits.... |
#ifndef CORE_BSINC_TABLES_H
#define CORE_BSINC_TABLES_H
#include <array>
#include "alspan.h"
#include "bsinc_defs.h"
#include "opthelpers.h"
struct BSincTable {
float scaleBase, scaleRange;
std::array<unsigned int,BSincScaleCount> m;
std::array<unsigned int,BSincScaleCount> filterOffset;
al::span<con... |
#ifndef CORE_BUFFERLINE_H
#define CORE_BUFFERLINE_H
#include <array>
#include "alspan.h"
/* Size for temporary storage of buffer data, in floats. Larger values need
* more memory and are harder on cache, while smaller values may need more
* iterations for mixing.
*/
inline constexpr size_t BufferLineSize{1024};
... |
#include "config.h"
#include "buffer_storage.h"
|
#ifndef CORE_BUFFER_STORAGE_H
#define CORE_BUFFER_STORAGE_H
#include <cstddef>
#include "alspan.h"
#include "ambidefs.h"
#include "storage_formats.h"
using uint = unsigned int;
constexpr bool IsBFormat(FmtChannels chans) noexcept
{ return chans == FmtBFormat2D || chans == FmtBFormat3D; }
/* Super Stereo is consid... |
#include "config.h"
#include <cassert>
#include <functional>
#include <limits>
#include <memory>
#include <stdexcept>
#include <utility>
#include "async_event.h"
#include "context.h"
#include "device.h"
#include "effectslot.h"
#include "logging.h"
#include "ringbuffer.h"
#include "voice.h"
#include "voice_change.h"
... |
#ifndef CORE_CONTEXT_H
#define CORE_CONTEXT_H
#include "config.h"
#include <array>
#include <atomic>
#include <bitset>
#include <cstddef>
#include <memory>
#include <thread>
#include <vector>
#include "alsem.h"
#include "alspan.h"
#include "async_event.h"
#include "atomic.h"
#include "flexarray.h"
#include "opthelpe... |
#include "config.h"
#include "converter.h"
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <climits>
#include "albit.h"
#include "alnumeric.h"
#include "fpu_ctrl.h"
namespace {
constexpr uint MaxPitch{10};
static_assert((BufferLineSize-... |
#ifndef CORE_CONVERTER_H
#define CORE_CONVERTER_H
#include <chrono>
#include <cstddef>
#include <memory>
#include "almalloc.h"
#include "devformat.h"
#include "flexarray.h"
#include "mixer/defs.h"
#include "resampler_limits.h"
using uint = unsigned int;
struct SampleConverter {
DevFmtType mSrcType{};
DevFm... |
#include "config.h"
#include "config_simd.h"
#include "cpu_caps.h"
#if defined(_WIN32) && (defined(_M_ARM) || defined(_M_ARM64))
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#ifndef PF_ARM_NEON_INSTRUCTIONS_AVAILABLE
#define PF_ARM_NEON_INSTRUCTIONS_AVAILABLE 19
#endif
#endif
#if defined(HAVE_CPUID_H)
#include ... |
#ifndef CORE_CPU_CAPS_H
#define CORE_CPU_CAPS_H
#include <optional>
#include <string>
inline int CPUCapFlags{0};
enum {
CPU_CAP_SSE = 1<<0,
CPU_CAP_SSE2 = 1<<1,
CPU_CAP_SSE3 = 1<<2,
CPU_CAP_SSE4_1 = 1<<3,
CPU_CAP_NEON = 1<<4,
};
struct CPUInfo {
std::string mVendor;
std::string ... |
#ifndef CORE_CUBIC_DEFS_H
#define CORE_CUBIC_DEFS_H
#include <array>
/* The number of distinct phase intervals within the cubic filter tables. */
constexpr unsigned int CubicPhaseBits{5};
constexpr unsigned int CubicPhaseCount{1 << CubicPhaseBits};
struct CubicCoefficients {
alignas(16) std::array<float,4> mCoef... |
#include "cubic_tables.h"
#include <array>
#include <cmath>
#include <cstddef>
#include "alnumbers.h"
#include "alnumeric.h"
#include "cubic_defs.h"
/* These gaussian filter tables are inspired by the gaussian-like filter found
* in the SNES. This is based on the public domain code developed by Near, with
* the h... |
#ifndef CORE_CUBIC_TABLES_H
#define CORE_CUBIC_TABLES_H
#include <array>
#include <cstddef>
#include "cubic_defs.h"
#include "opthelpers.h"
struct SIMDALIGN CubicTable {
std::array<CubicCoefficients,CubicPhaseCount> mTable{};
};
struct GaussianTable : CubicTable { GaussianTable(); };
inline const GaussianTable... |
#include "config.h"
#include "dbus_wrap.h"
#if HAVE_DYNLOAD
#include <mutex>
#include <type_traits>
#include "logging.h"
void PrepareDBus()
{
const char *libname{"libdbus-1.so.3"};
dbus_handle = LoadLib(libname);
if(!dbus_handle)
{
WARN("Failed to load {}", libname);
return;
... |
#ifndef CORE_DBUS_WRAP_H
#define CORE_DBUS_WRAP_H
#include <memory>
#include <dbus/dbus.h>
#include "dynload.h"
#if HAVE_DYNLOAD
#include <mutex>
#define DBUS_FUNCTIONS(MAGIC) \
MAGIC(dbus_error_init) \
MAGIC(dbus_error_free) \
MAGIC(dbus_bus_get) \
MAGIC(dbus_connection_set_exit_on_disconnect) \
MAGIC(dbus_conne... |
#include "config.h"
#include "devformat.h"
#include <string_view>
namespace {
using namespace std::string_view_literals;
} // namespace
uint BytesFromDevFmt(DevFmtType type) noexcept
{
switch(type)
{
case DevFmtByte: return sizeof(int8_t);
case DevFmtUByte: return sizeof(uint8_t);
case DevFmtSh... |
#ifndef CORE_DEVFORMAT_H
#define CORE_DEVFORMAT_H
#include <cstdint>
#include <cstddef>
#include <string_view>
using uint = unsigned int;
enum Channel : unsigned char {
FrontLeft = 0,
FrontRight,
FrontCenter,
LFE,
BackLeft,
BackRight,
BackCenter,
SideLeft,
SideRight,
TopCent... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.