AuroraMiddleware/AuroraOpenALSoft
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Avoid global constexpr arrays

Browse Source
This commit is contained in:
Chris Robinson 2021-01-21 02:05:55 -08:00
parent 92c653e5f0
commit 20f5e7c1fa
10 changed files with 172 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -648,7 +648,6 @@ set(COMMON_OBJS
set(CORE_OBJS
core/ambdec.cpp
core/ambdec.h
core/ambidefs.cpp
core/ambidefs.h
core/bs2b.cpp
core/bs2b.h

4
al/source.cpp
View File

@ -471,8 +471,8 @@ void InitVoice(Voice *voice, ALsource *source, BufferlistItem *BufferList, ALCco
if(voice->mAmbiOrder && device->mAmbiOrder > voice->mAmbiOrder)
{
const uint8_t *OrderFromChan{(voice->mFmtChannels == FmtBFormat2D) ?
AmbiIndex::OrderFrom2DChannel.data() :
AmbiIndex::OrderFromChannel.data()};
AmbiIndex::OrderFrom2DChannel().data() :
AmbiIndex::OrderFromChannel().data()};
const auto scales = BFormatDec::GetHFOrderScales(voice->mAmbiOrder, device->mAmbiOrder);
const BandSplitter splitter{device->mXOverFreq / static_cast<float>(device->Frequency)};

4
alc/alc.cpp
View File

@ -2212,8 +2212,8 @@ static ALCenum UpdateDeviceParams(ALCdevice *device, const int *attrList)
if(voice->mAmbiOrder && device->mAmbiOrder > voice->mAmbiOrder)
{
const uint8_t *OrderFromChan{(voice->mFmtChannels == FmtBFormat2D) ?
AmbiIndex::OrderFrom2DChannel.data() :
AmbiIndex::OrderFromChannel.data()};
AmbiIndex::OrderFrom2DChannel().data() :
AmbiIndex::OrderFromChannel().data()};
const BandSplitter splitter{device->mXOverFreq /
static_cast<float>(device->Frequency)};

24
alc/alu.cpp
View File

@ -345,23 +345,23 @@ inline uint dither_rng(uint *seed) noexcept
}
auto GetAmbiScales(AmbiScaling scaletype) noexcept -> const std::array<float,MaxAmbiChannels>&
inline auto& GetAmbiScales(AmbiScaling scaletype) noexcept
{
if(scaletype == AmbiScaling::FuMa) return AmbiScale::FromFuMa;
if(scaletype == AmbiScaling::SN3D) return AmbiScale::FromSN3D;
return AmbiScale::FromN3D;
if(scaletype == AmbiScaling::FuMa) return AmbiScale::FromFuMa();
if(scaletype == AmbiScaling::SN3D) return AmbiScale::FromSN3D();
return AmbiScale::FromN3D();
}
auto GetAmbiLayout(AmbiLayout layouttype) noexcept -> const std::array<uint8_t,MaxAmbiChannels>&
inline auto& GetAmbiLayout(AmbiLayout layouttype) noexcept
{
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa;
return AmbiIndex::FromACN;
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa();
return AmbiIndex::FromACN();
}
auto GetAmbi2DLayout(AmbiLayout layouttype) noexcept -> const std::array<uint8_t,MaxAmbi2DChannels>&
inline auto& GetAmbi2DLayout(AmbiLayout layouttype) noexcept
{
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D;
return AmbiIndex::FromACN2D;
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D();
return AmbiIndex::FromACN2D();
}
@ -855,7 +855,7 @@ void CalcPanningAndFilters(Voice *voice, const float xpos, const float ypos, con
std::bind(std::multiplies<float>{}, _1, 1.0f-coverage));
/* NOTE: W needs to be scaled according to channel scaling. */
const auto &scales = GetAmbiScales(voice->mAmbiScaling);
auto&& scales = GetAmbiScales(voice->mAmbiScaling);
ComputePanGains(&Device->Dry, coeffs.data(), DryGain.Base*scales[0],
voice->mChans[0].mDryParams.Gains.Target);
for(uint i{0};i < NumSends;i++)
@ -907,7 +907,7 @@ void CalcPanningAndFilters(Voice *voice, const float xpos, const float ypos, con
for(size_t c{1};c < num_channels;c++)
{
const size_t acn{index_map[c]};
const size_t order{AmbiIndex::OrderFromChannel[acn]};
const size_t order{AmbiIndex::OrderFromChannel()[acn]};
const size_t tocopy{ChansPerOrder[order]};
const size_t offset{OrderOffset[order]};
const float scale{scales[acn] * coverage};

21
alc/bformatdec.cpp
View File

@ -31,19 +31,18 @@ constexpr std::array<float,MaxAmbiOrder+1> Ambi3DDecoderHFScale3O{{
5.89792205e-01f, 8.79693856e-01f, 1.00000000e+00f, 1.00000000e+00f
}};
inline auto GetDecoderHFScales(uint order) noexcept -> const std::array<float,MaxAmbiOrder+1>&
inline auto& GetDecoderHFScales(uint order) noexcept
{
if(order >= 3) return Ambi3DDecoderHFScale3O;
if(order == 2) return Ambi3DDecoderHFScale2O;
return Ambi3DDecoderHFScale;
}
inline auto GetAmbiScales(AmbDecScale scaletype) noexcept
-> const std::array<float,MaxAmbiChannels>&
inline auto& GetAmbiScales(AmbDecScale scaletype) noexcept
{
if(scaletype == AmbDecScale::FuMa) return AmbiScale::FromFuMa;
if(scaletype == AmbDecScale::SN3D) return AmbiScale::FromSN3D;
return AmbiScale::FromN3D;
if(scaletype == AmbDecScale::FuMa) return AmbiScale::FromFuMa();
if(scaletype == AmbDecScale::SN3D) return AmbiScale::FromSN3D();
return AmbiScale::FromN3D();
}
} // namespace
@ -56,15 +55,15 @@ BFormatDec::BFormatDec(const AmbDecConf *conf, const bool allow_2band, const siz
, mChannelDec{inchans}
{
const bool periphonic{(conf->ChanMask&AmbiPeriphonicMask) != 0};
const std::array<float,MaxAmbiChannels> &coeff_scale = GetAmbiScales(conf->CoeffScale);
auto&& coeff_scale = GetAmbiScales(conf->CoeffScale);
if(!mDualBand)
{
for(size_t j{0},k{0};j < mChannelDec.size();++j)
{
const size_t acn{periphonic ? j : AmbiIndex::FromACN2D[j]};
const size_t acn{periphonic ? j : AmbiIndex::FromACN2D()[j]};
if(!(conf->ChanMask&(1u<<acn))) continue;
const size_t order{AmbiIndex::OrderFromChannel[acn]};
const size_t order{AmbiIndex::OrderFromChannel()[acn]};
const float gain{conf->HFOrderGain[order] / coeff_scale[acn]};
for(size_t i{0u};i < conf->NumSpeakers;++i)
{
@ -83,9 +82,9 @@ BFormatDec::BFormatDec(const AmbDecConf *conf, const bool allow_2band, const siz
const float ratio{std::pow(10.0f, conf->XOverRatio / 40.0f)};
for(size_t j{0},k{0};j < mChannelDec.size();++j)
{
const size_t acn{periphonic ? j : AmbiIndex::FromACN2D[j]};
const size_t acn{periphonic ? j : AmbiIndex::FromACN2D()[j]};
if(!(conf->ChanMask&(1u<<acn))) continue;
const size_t order{AmbiIndex::OrderFromChannel[acn]};
const size_t order{AmbiIndex::OrderFromChannel()[acn]};
const float hfGain{conf->HFOrderGain[order] * ratio / coeff_scale[acn]};
const float lfGain{conf->LFOrderGain[order] / ratio / coeff_scale[acn]};
for(size_t i{0u};i < conf->NumSpeakers;++i)

22
alc/effects/convolution.cpp
View File

@ -76,23 +76,23 @@ void LoadSamples(double *RESTRICT dst, const al::byte *src, const size_t srcstep
}
auto GetAmbiScales(AmbiScaling scaletype) noexcept -> const std::array<float,MaxAmbiChannels>&
inline auto& GetAmbiScales(AmbiScaling scaletype) noexcept
{
if(scaletype == AmbiScaling::FuMa) return AmbiScale::FromFuMa;
if(scaletype == AmbiScaling::SN3D) return AmbiScale::FromSN3D;
return AmbiScale::FromN3D;
if(scaletype == AmbiScaling::FuMa) return AmbiScale::FromFuMa();
if(scaletype == AmbiScaling::SN3D) return AmbiScale::FromSN3D();
return AmbiScale::FromN3D();
}
auto GetAmbiLayout(AmbiLayout layouttype) noexcept -> const std::array<uint8_t,MaxAmbiChannels>&
inline auto& GetAmbiLayout(AmbiLayout layouttype) noexcept
{
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa;
return AmbiIndex::FromACN;
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa();
return AmbiIndex::FromACN();
}
auto GetAmbi2DLayout(AmbiLayout layouttype) noexcept -> const std::array<uint8_t,MaxAmbi2DChannels>&
inline auto& GetAmbi2DLayout(AmbiLayout layouttype) noexcept
{
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D;
return AmbiIndex::FromACN2D;
if(layouttype == AmbiLayout::FuMa) return AmbiIndex::FromFuMa2D();
return AmbiIndex::FromACN2D();
}
@ -387,7 +387,7 @@ void ConvolutionState::update(const ALCcontext *context, const EffectSlot *slot,
}
mOutTarget = target.Main->Buffer;
const auto &scales = GetAmbiScales(mAmbiScaling);
auto&& scales = GetAmbiScales(mAmbiScaling);
const uint8_t *index_map{(mChannels == FmtBFormat2D) ?
GetAmbi2DLayout(mAmbiLayout).data() :
GetAmbiLayout(mAmbiLayout).data()};

2
alc/hrtf.cpp
View File

@ -291,7 +291,7 @@ void DirectHrtfState::build(const HrtfStore *Hrtf, const uint irSize,
const double xover_norm{double{XOverFreq} / Hrtf->sampleRate};
for(size_t i{0};i < mChannels.size();++i)
{
const size_t order{AmbiIndex::OrderFromChannel[i]};
const size_t order{AmbiIndex::OrderFromChannel()[i]};
mChannels[i].mSplitter.init(static_cast<float>(xover_norm));
mChannels[i].mHfScale = AmbiOrderHFGain[order];
}

37
alc/panning.cpp
View File

@ -300,17 +300,17 @@ void InitDistanceComp(ALCdevice *device, const AmbDecConf *conf,
}
auto GetAmbiScales(DevAmbiScaling scaletype) noexcept -> const std::array<float,MaxAmbiChannels>&
inline auto& GetAmbiScales(DevAmbiScaling scaletype) noexcept
{
if(scaletype == DevAmbiScaling::FuMa) return AmbiScale::FromFuMa;
if(scaletype == DevAmbiScaling::SN3D) return AmbiScale::FromSN3D;
return AmbiScale::FromN3D;
if(scaletype == DevAmbiScaling::FuMa) return AmbiScale::FromFuMa();
if(scaletype == DevAmbiScaling::SN3D) return AmbiScale::FromSN3D();
return AmbiScale::FromN3D();
}
auto GetAmbiLayout(DevAmbiLayout layouttype) noexcept -> const std::array<uint8_t,MaxAmbiChannels>&
inline auto& GetAmbiLayout(DevAmbiLayout layouttype) noexcept
{
if(layouttype == DevAmbiLayout::FuMa) return AmbiIndex::FromFuMa;
return AmbiIndex::FromACN;
if(layouttype == DevAmbiLayout::FuMa) return AmbiIndex::FromFuMa();
return AmbiIndex::FromACN();
}
@ -492,8 +492,8 @@ void InitPanning(ALCdevice *device, const bool hqdec=false, const bool stablize=
if(device->FmtChans == DevFmtAmbi3D)
{
const char *devname{device->DeviceName.c_str()};
const std::array<uint8_t,MaxAmbiChannels> &acnmap = GetAmbiLayout(device->mAmbiLayout);
const std::array<float,MaxAmbiChannels> &n3dscale = GetAmbiScales(device->mAmbiScale);
auto&& acnmap = GetAmbiLayout(device->mAmbiLayout);
auto&& n3dscale = GetAmbiScales(device->mAmbiScale);
/* For DevFmtAmbi3D, the ambisonic order is already set. */
const size_t count{AmbiChannelsFromOrder(device->mAmbiOrder)};
@ -554,7 +554,7 @@ void InitPanning(ALCdevice *device, const bool hqdec=false, const bool stablize=
/* Built-in speaker decoders are always 2D. */
const size_t ambicount{Ambi2DChannelsFromOrder(decoder.mOrder)};
std::transform(AmbiIndex::FromACN2D.begin(), AmbiIndex::FromACN2D.begin()+ambicount,
std::transform(AmbiIndex::FromACN2D().begin(), AmbiIndex::FromACN2D().begin()+ambicount,
std::begin(device->Dry.AmbiMap),
[](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
);
@ -611,7 +611,7 @@ void InitCustomPanning(ALCdevice *device, const bool hqdec, const bool stablize,
if((conf->ChanMask&AmbiPeriphonicMask))
{
count = AmbiChannelsFromOrder(order);
std::transform(AmbiIndex::FromACN.begin(), AmbiIndex::FromACN.begin()+count,
std::transform(AmbiIndex::FromACN().begin(), AmbiIndex::FromACN().begin()+count,
std::begin(device->Dry.AmbiMap),
[](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
);
@ -619,7 +619,7 @@ void InitCustomPanning(ALCdevice *device, const bool hqdec, const bool stablize,
else
{
count = Ambi2DChannelsFromOrder(order);
std::transform(AmbiIndex::FromACN2D.begin(), AmbiIndex::FromACN2D.begin()+count,
std::transform(AmbiIndex::FromACN2D().begin(), AmbiIndex::FromACN2D().begin()+count,
std::begin(device->Dry.AmbiMap),
[](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
);
@ -812,7 +812,7 @@ void InitHrtfPanning(ALCdevice *device)
device->mAmbiOrder = ambi_order;
const size_t count{AmbiChannelsFromOrder(ambi_order)};
std::transform(AmbiIndex::FromACN.begin(), AmbiIndex::FromACN.begin()+count,
std::transform(AmbiIndex::FromACN().begin(), AmbiIndex::FromACN().begin()+count,
std::begin(device->Dry.AmbiMap),
[](const uint8_t &index) noexcept { return BFChannelConfig{1.0f, index}; }
);
@ -834,11 +834,10 @@ void InitUhjPanning(ALCdevice *device)
device->mAmbiOrder = 1;
auto acnmap_end = AmbiIndex::FromFuMa.begin() + count;
std::transform(AmbiIndex::FromFuMa.begin(), acnmap_end, std::begin(device->Dry.AmbiMap),
auto acnmap_begin = AmbiIndex::FromFuMa().begin();
std::transform(acnmap_begin, acnmap_begin + count, std::begin(device->Dry.AmbiMap),
[](const uint8_t &acn) noexcept -> BFChannelConfig
{ return BFChannelConfig{1.0f/AmbiScale::FromFuMa[acn], acn}; }
);
{ return BFChannelConfig{1.0f/AmbiScale::FromFuMa()[acn], acn}; });
AllocChannels(device, count, device->channelsFromFmt());
}
@ -1092,8 +1091,8 @@ void aluInitEffectPanning(EffectSlot *slot, ALCcontext *context)
WetBuffer *wetbuffer{slot->mWetBuffer = wetbuffer_iter->get()};
wetbuffer->mInUse = true;
auto acnmap_end = AmbiIndex::FromACN.begin() + count;
auto iter = std::transform(AmbiIndex::FromACN.begin(), acnmap_end, slot->Wet.AmbiMap.begin(),
auto acnmap_begin = AmbiIndex::FromACN().begin();
auto iter = std::transform(acnmap_begin, acnmap_begin + count, slot->Wet.AmbiMap.begin(),
[](const uint8_t &acn) noexcept -> BFChannelConfig
{ return BFChannelConfig{1.0f, acn}; });
std::fill(iter, slot->Wet.AmbiMap.end(), BFChannelConfig{});

15
core/ambidefs.cpp
View File

@ -1,15 +0,0 @@
#include "config.h"
#include "ambidefs.h"
constexpr std::array<float,MaxAmbiChannels> AmbiScale::FromN3D;
constexpr std::array<float,MaxAmbiChannels> AmbiScale::FromSN3D;
constexpr std::array<float,MaxAmbiChannels> AmbiScale::FromFuMa;
constexpr std::array<uint8_t,MaxAmbiChannels> AmbiIndex::FromFuMa;
constexpr std::array<uint8_t,MaxAmbi2DChannels> AmbiIndex::FromFuMa2D;
constexpr std::array<uint8_t,MaxAmbiChannels> AmbiIndex::FromACN;
constexpr std::array<uint8_t,MaxAmbi2DChannels> AmbiIndex::FromACN2D;
constexpr std::array<uint8_t,MaxAmbiChannels> AmbiIndex::OrderFromChannel;
constexpr std::array<uint8_t,MaxAmbi2DChannels> AmbiIndex::OrderFrom2DChannel;

196
core/ambidefs.h
View File

@ -45,91 +45,127 @@ constexpr size_t MaxAmbi2DChannels{Ambi2DChannelsFromOrder(MaxAmbiOrder)};
* coefficients should be divided by these values to get proper scalings.
*/
struct AmbiScale {
static constexpr std::array<float,MaxAmbiChannels> FromN3D{{
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
}};
static constexpr std::array<float,MaxAmbiChannels> FromSN3D{{
1.000000000f, /* ACN 0, sqrt(1) */
1.732050808f, /* ACN 1, sqrt(3) */
1.732050808f, /* ACN 2, sqrt(3) */
1.732050808f, /* ACN 3, sqrt(3) */
2.236067978f, /* ACN 4, sqrt(5) */
2.236067978f, /* ACN 5, sqrt(5) */
2.236067978f, /* ACN 6, sqrt(5) */
2.236067978f, /* ACN 7, sqrt(5) */
2.236067978f, /* ACN 8, sqrt(5) */
2.645751311f, /* ACN 9, sqrt(7) */
2.645751311f, /* ACN 10, sqrt(7) */
2.645751311f, /* ACN 11, sqrt(7) */
2.645751311f, /* ACN 12, sqrt(7) */
2.645751311f, /* ACN 13, sqrt(7) */
2.645751311f, /* ACN 14, sqrt(7) */
2.645751311f, /* ACN 15, sqrt(7) */
}};
static constexpr std::array<float,MaxAmbiChannels> FromFuMa{{
1.414213562f, /* ACN 0 (W), sqrt(2) */
1.732050808f, /* ACN 1 (Y), sqrt(3) */
1.732050808f, /* ACN 2 (Z), sqrt(3) */
1.732050808f, /* ACN 3 (X), sqrt(3) */
1.936491673f, /* ACN 4 (V), sqrt(15)/2 */
1.936491673f, /* ACN 5 (T), sqrt(15)/2 */
2.236067978f, /* ACN 6 (R), sqrt(5) */
1.936491673f, /* ACN 7 (S), sqrt(15)/2 */
1.936491673f, /* ACN 8 (U), sqrt(15)/2 */
2.091650066f, /* ACN 9 (Q), sqrt(35/8) */
1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
2.231093404f, /* ACN 11 (M), sqrt(224/45) */
2.645751311f, /* ACN 12 (K), sqrt(7) */
2.231093404f, /* ACN 13 (L), sqrt(224/45) */
1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
2.091650066f, /* ACN 15 (P), sqrt(35/8) */
}};
static auto& FromN3D() noexcept
{
static constexpr const std::array<float,MaxAmbiChannels> ret{{
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f
}};
return ret;
}
static auto& FromSN3D() noexcept
{
static constexpr const std::array<float,MaxAmbiChannels> ret{{
1.000000000f, /* ACN 0, sqrt(1) */
1.732050808f, /* ACN 1, sqrt(3) */
1.732050808f, /* ACN 2, sqrt(3) */
1.732050808f, /* ACN 3, sqrt(3) */
2.236067978f, /* ACN 4, sqrt(5) */
2.236067978f, /* ACN 5, sqrt(5) */
2.236067978f, /* ACN 6, sqrt(5) */
2.236067978f, /* ACN 7, sqrt(5) */
2.236067978f, /* ACN 8, sqrt(5) */
2.645751311f, /* ACN 9, sqrt(7) */
2.645751311f, /* ACN 10, sqrt(7) */
2.645751311f, /* ACN 11, sqrt(7) */
2.645751311f, /* ACN 12, sqrt(7) */
2.645751311f, /* ACN 13, sqrt(7) */
2.645751311f, /* ACN 14, sqrt(7) */
2.645751311f, /* ACN 15, sqrt(7) */
}};
return ret;
}
static auto& FromFuMa() noexcept
{
static constexpr const std::array<float,MaxAmbiChannels> ret{{
1.414213562f, /* ACN 0 (W), sqrt(2) */
1.732050808f, /* ACN 1 (Y), sqrt(3) */
1.732050808f, /* ACN 2 (Z), sqrt(3) */
1.732050808f, /* ACN 3 (X), sqrt(3) */
1.936491673f, /* ACN 4 (V), sqrt(15)/2 */
1.936491673f, /* ACN 5 (T), sqrt(15)/2 */
2.236067978f, /* ACN 6 (R), sqrt(5) */
1.936491673f, /* ACN 7 (S), sqrt(15)/2 */
1.936491673f, /* ACN 8 (U), sqrt(15)/2 */
2.091650066f, /* ACN 9 (Q), sqrt(35/8) */
1.972026594f, /* ACN 10 (O), sqrt(35)/3 */
2.231093404f, /* ACN 11 (M), sqrt(224/45) */
2.645751311f, /* ACN 12 (K), sqrt(7) */
2.231093404f, /* ACN 13 (L), sqrt(224/45) */
1.972026594f, /* ACN 14 (N), sqrt(35)/3 */
2.091650066f, /* ACN 15 (P), sqrt(35/8) */
}};
return ret;
}
};
struct AmbiIndex {
static constexpr std::array<uint8_t,MaxAmbiChannels> FromFuMa{{
0, /* W */
3, /* X */
1, /* Y */
2, /* Z */
6, /* R */
7, /* S */
5, /* T */
8, /* U */
4, /* V */
12, /* K */
13, /* L */
11, /* M */
14, /* N */
10, /* O */
15, /* P */
9, /* Q */
}};
static constexpr std::array<uint8_t,MaxAmbi2DChannels> FromFuMa2D{{
0, /* W */
3, /* X */
1, /* Y */
8, /* U */
4, /* V */
15, /* P */
9, /* Q */
}};
static auto& FromFuMa() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
0, /* W */
3, /* X */
1, /* Y */
2, /* Z */
6, /* R */
7, /* S */
5, /* T */
8, /* U */
4, /* V */
12, /* K */
13, /* L */
11, /* M */
14, /* N */
10, /* O */
15, /* P */
9, /* Q */
}};
return ret;
}
static auto& FromFuMa2D() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
0, /* W */
3, /* X */
1, /* Y */
8, /* U */
4, /* V */
15, /* P */
9, /* Q */
}};
return ret;
}
static constexpr std::array<uint8_t,MaxAmbiChannels> FromACN{{
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15
}};
static constexpr std::array<uint8_t,MaxAmbi2DChannels> FromACN2D{{
0, 1,3, 4,8, 9,15
}};
static auto& FromACN() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15
}};
return ret;
}
static auto& FromACN2D() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
0, 1,3, 4,8, 9,15
}};
return ret;
}
static constexpr std::array<uint8_t,MaxAmbiChannels> OrderFromChannel{{
0, 1,1,1, 2,2,2,2,2, 3,3,3,3,3,3,3,
}};
static constexpr std::array<uint8_t,MaxAmbi2DChannels> OrderFrom2DChannel{{
0, 1,1, 2,2, 3,3,
}};
static auto& OrderFromChannel() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbiChannels> ret{{
0, 1,1,1, 2,2,2,2,2, 3,3,3,3,3,3,3,
}};
return ret;
}
static auto& OrderFrom2DChannel() noexcept
{
static constexpr const std::array<uint8_t,MaxAmbi2DChannels> ret{{
0, 1,1, 2,2, 3,3,
}};
return ret;
}
};
#endif /* CORE_AMBIDEFS_H */