TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-01-19 20:24:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
Torque3D/Engine/lib/openal-soft/examples/allafplay.cpp

1013 lines
37 KiB
C++
Raw Blame History

/*
* OpenAL LAF Playback Example
*
* Copyright (c) 2024 by Chris Robinson <chris.kcat@gmail.com>
*
* 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 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.
*/
/* This file contains an example for playback of Limitless Audio Format files.
*
* Some current shortcomings:
*
* - 256 track limit. Could be made higher, but making it too flexible would
* necessitate more micro-allocations.
*
* - "Objects" mode only supports sample rates that are a multiple of 48. Since
* positions are specified as samples in extra channels/tracks, and 3*16
* samples are needed per track to specify the full set of positions, and
* each chunk is exactly one second long, other sample rates would result in
* the positions being split across chunks, causing the source playback
* offset to go out of sync with the offset used to look up the current
* spatial positions. Fixing this will require slightly more work to update
* and synchronize the spatial position arrays against the playback offset.
*
* - Updates are specified as fast as the app can detect and react to the
* reported source offset (that in turn depends on how often OpenAL renders).
* This can cause some positions to be a touch late and lose some granular
* temporal movement. In practice, this should probably be good enough for
* most use-cases. Fixing this would need either a new extension to queue
* position changes to apply when needed, or use a separate loopback device
* to render with and control the number of samples rendered between updates
* (with a second device to do the actual playback).
*
* - The LAF documentation doesn't prohibit object position tracks from being
* separated with audio tracks in between, or from being the first tracks
* followed by the audio tracks. It's not known if this is intended to be
* allowed, but it's not supported. Object position tracks must be last.
*
* Some remaining issues:
*
* - There are bursts of static on some channels. This doesn't appear to be a
* parsing error since the bursts last less than the chunk size, and it never
* loses sync with the remaining chunks. Might be an encoding error with the
* files tested.
*
* - Positions are specified in left-handed coordinates, despite the LAF
* documentation saying it's right-handed. Might be an encoding error with
* the files tested, or might be a misunderstanding about which is which. How
* to proceed may depend on how wide-spread this issue ends up being, but for
* now, they're treated as left-handed here.
*
* - The LAF documentation doesn't specify the range or direction for the
* channels' X and Y axis rotation in Channels mode. Presumably X rotation
* (elevation) goes from -pi/2...+pi/2 and Y rotation (azimuth) goes from
* either -pi...+pi or 0...pi*2, but the direction of movement isn't
* specified. Currently positive azimuth moves from center rightward and
* positive elevation moves from head-level upward.
*/
#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <fstream>
#include <memory>
#include <numeric>
#include <string>
#include <string_view>
#include <thread>
#include <type_traits>
#include <vector>
#include "AL/alc.h"
#include "AL/al.h"
#include "AL/alext.h"
#include "albit.h"
#include "almalloc.h"
#include "alnumeric.h"
#include "alspan.h"
#include "alstring.h"
#include "common/alhelpers.h"
#include "filesystem.h"
#include "fmt/core.h"
#include "fmt/std.h"
#include "win_main_utf8.h"
namespace {
/* Filter object functions */
auto alGenFilters = LPALGENFILTERS{};
auto alDeleteFilters = LPALDELETEFILTERS{};
auto alIsFilter = LPALISFILTER{};
auto alFilteri = LPALFILTERI{};
auto alFilteriv = LPALFILTERIV{};
auto alFilterf = LPALFILTERF{};
auto alFilterfv = LPALFILTERFV{};
auto alGetFilteri = LPALGETFILTERI{};
auto alGetFilteriv = LPALGETFILTERIV{};
auto alGetFilterf = LPALGETFILTERF{};
auto alGetFilterfv = LPALGETFILTERFV{};
/* Effect object functions */
auto alGenEffects = LPALGENEFFECTS{};
auto alDeleteEffects = LPALDELETEEFFECTS{};
auto alIsEffect = LPALISEFFECT{};
auto alEffecti = LPALEFFECTI{};
auto alEffectiv = LPALEFFECTIV{};
auto alEffectf = LPALEFFECTF{};
auto alEffectfv = LPALEFFECTFV{};
auto alGetEffecti = LPALGETEFFECTI{};
auto alGetEffectiv = LPALGETEFFECTIV{};
auto alGetEffectf = LPALGETEFFECTF{};
auto alGetEffectfv = LPALGETEFFECTFV{};
/* Auxiliary Effect Slot object functions */
auto alGenAuxiliaryEffectSlots = LPALGENAUXILIARYEFFECTSLOTS{};
auto alDeleteAuxiliaryEffectSlots = LPALDELETEAUXILIARYEFFECTSLOTS{};
auto alIsAuxiliaryEffectSlot = LPALISAUXILIARYEFFECTSLOT{};
auto alAuxiliaryEffectSloti = LPALAUXILIARYEFFECTSLOTI{};
auto alAuxiliaryEffectSlotiv = LPALAUXILIARYEFFECTSLOTIV{};
auto alAuxiliaryEffectSlotf = LPALAUXILIARYEFFECTSLOTF{};
auto alAuxiliaryEffectSlotfv = LPALAUXILIARYEFFECTSLOTFV{};
auto alGetAuxiliaryEffectSloti = LPALGETAUXILIARYEFFECTSLOTI{};
auto alGetAuxiliaryEffectSlotiv = LPALGETAUXILIARYEFFECTSLOTIV{};
auto alGetAuxiliaryEffectSlotf = LPALGETAUXILIARYEFFECTSLOTF{};
auto alGetAuxiliaryEffectSlotfv = LPALGETAUXILIARYEFFECTSLOTFV{};
auto MuteFilterID = ALuint{};
auto LowFrequencyEffectID = ALuint{};
auto LfeSlotID = ALuint{};
using namespace std::string_view_literals;
[[noreturn]]
void do_assert(const char *message, int linenum, const char *filename, const char *funcname)
{
auto errstr = fmt::format("{}:{}: {}: {}", filename, linenum, funcname, message);
throw std::runtime_error{errstr};
}
#define MyAssert(cond) do { \
if(!(cond)) UNLIKELY \
do_assert("Assertion '" #cond "' failed", __LINE__, __FILE__, \
std::data(__func__)); \
} while(0)
enum class Quality : std::uint8_t {
s8, s16, f32, s24
};
enum class Mode : bool {
Channels, Objects
};
auto GetQualityName(Quality quality) noexcept -> std::string_view
{
switch(quality)
{
case Quality::s8: return "8-bit int"sv;
case Quality::s16: return "16-bit int"sv;
case Quality::f32: return "32-bit float"sv;
case Quality::s24: return "24-bit int"sv;
}
return "<unknown>"sv;
}
auto GetModeName(Mode mode) noexcept -> std::string_view
{
switch(mode)
{
case Mode::Channels: return "channels"sv;
case Mode::Objects: return "objects"sv;
}
return "<unknown>"sv;
}
auto BytesFromQuality(Quality quality) noexcept -> size_t
{
switch(quality)
{
case Quality::s8: return 1;
case Quality::s16: return 2;
case Quality::f32: return 4;
case Quality::s24: return 3;
}
return 4;
}
auto BufferBytesFromQuality(Quality quality) noexcept -> size_t
{
switch(quality)
{
case Quality::s8: return 1;
case Quality::s16: return 2;
case Quality::f32: return 4;
/* 24-bit samples are converted to 32-bit for OpenAL. */
case Quality::s24: return 4;
}
return 4;
}
/* Helper class for reading little-endian samples on big-endian targets, or
* convert 24-bit samples.
*/
template<Quality Q>
struct SampleReader;
template<>
struct SampleReader<Quality::s8> {
using src_t = int8_t;
using dst_t = int8_t;
[[nodiscard]] static
auto read(const src_t &in) noexcept -> dst_t { return in; }
};
template<>
struct SampleReader<Quality::s16> {
using src_t = int16_t;
using dst_t = int16_t;
[[nodiscard]] static
auto read(const src_t &in) noexcept -> dst_t
{
if constexpr(al::endian::native == al::endian::little)
return in;
else
return al::byteswap(in);
}
};
template<>
struct SampleReader<Quality::f32> {
/* 32-bit float samples are read as 32-bit integer on big-endian systems,
* so that they can be byteswapped before being reinterpreted as float.
*/
using src_t = std::conditional_t<al::endian::native==al::endian::little, float,uint32_t>;
using dst_t = float;
[[nodiscard]] static
auto read(const src_t &in) noexcept -> dst_t
{
if constexpr(al::endian::native == al::endian::little)
return in;
else
return al::bit_cast<dst_t>(al::byteswap(static_cast<uint32_t>(in)));
}
};
template<>
struct SampleReader<Quality::s24> {
/* 24-bit samples are converted to 32-bit integer. */
using src_t = std::array<uint8_t,3>;
using dst_t = int32_t;
[[nodiscard]] static
auto read(const src_t &in) noexcept -> dst_t
{
return static_cast<int32_t>((uint32_t{in[0]}<<8) | (uint32_t{in[1]}<<16)
| (uint32_t{in[2]}<<24));
}
};
/* Each track with position data consists of a set of 3 samples per 16 audio
* channels, resulting in a full set of positions being specified over 48
* sample frames.
*/
constexpr auto FramesPerPos = 48_uz;
struct Channel {
ALuint mSource{};
std::array<ALuint,2> mBuffers{};
float mAzimuth{};
float mElevation{};
bool mIsLfe{};
Channel() = default;
Channel(const Channel&) = delete;
Channel(Channel&& rhs)
: mSource{rhs.mSource}, mBuffers{rhs.mBuffers}, mAzimuth{rhs.mAzimuth}
, mElevation{rhs.mElevation}, mIsLfe{rhs.mIsLfe}
{
rhs.mSource = 0;
rhs.mBuffers.fill(0);
}
~Channel()
{
if(mSource) alDeleteSources(1, &mSource);
if(mBuffers[0]) alDeleteBuffers(ALsizei(mBuffers.size()), mBuffers.data());
}
auto operator=(const Channel&) -> Channel& = delete;
auto operator=(Channel&& rhs) -> Channel&
{
std::swap(mSource, rhs.mSource);
std::swap(mBuffers, rhs.mBuffers);
std::swap(mAzimuth, rhs.mAzimuth);
std::swap(mElevation, rhs.mElevation);
std::swap(mIsLfe, rhs.mIsLfe);
return *this;
}
};
struct LafStream {
std::filebuf mInFile;
Quality mQuality{};
Mode mMode{};
uint32_t mNumTracks{};
uint32_t mSampleRate{};
ALenum mALFormat{};
uint64_t mSampleCount{};
uint64_t mCurrentSample{};
std::array<uint8_t,32> mEnabledTracks{};
uint32_t mNumEnabled{};
std::vector<char> mSampleChunk;
al::span<char> mSampleLine;
std::vector<Channel> mChannels;
std::vector<std::vector<float>> mPosTracks;
LafStream() = default;
LafStream(const LafStream&) = delete;
~LafStream() = default;
auto operator=(const LafStream&) -> LafStream& = delete;
[[nodiscard]]
auto readChunk() -> uint32_t;
void convertSamples(const al::span<char> samples) const;
void convertPositions(const al::span<float> dst, const al::span<const char> src) const;
template<Quality Q>
void copySamples(char *dst, const char *src, size_t idx, size_t count) const;
[[nodiscard]]
auto prepareTrack(size_t trackidx, size_t count) -> al::span<char>;
[[nodiscard]]
auto isAtEnd() const noexcept -> bool { return mCurrentSample >= mSampleCount; }
};
auto LafStream::readChunk() -> uint32_t
{
mEnabledTracks.fill(0);
mInFile.sgetn(reinterpret_cast<char*>(mEnabledTracks.data()), (mNumTracks+7_z)>>3);
mNumEnabled = std::accumulate(mEnabledTracks.cbegin(), mEnabledTracks.cend(), 0u,
[](const unsigned int val, const uint8_t in)
{ return val + unsigned(al::popcount(unsigned(in))); });
/* Make sure enable bits aren't set for non-existent tracks. */
if(mEnabledTracks[((mNumTracks+7_uz)>>3) - 1] >= (1u<<(mNumTracks&7)))
throw std::runtime_error{"Invalid channel enable bits"};
/* Each chunk is exactly one second long, with samples interleaved for each
* enabled track. The last chunk may be shorter if there isn't enough time
* remaining for a full second.
*/
const auto numsamples = std::min(uint64_t{mSampleRate}, mSampleCount-mCurrentSample);
const auto toread = std::streamsize(numsamples * BytesFromQuality(mQuality) * mNumEnabled);
if(mInFile.sgetn(mSampleChunk.data(), toread) != toread)
throw std::runtime_error{"Failed to read sample chunk"};
std::fill(mSampleChunk.begin()+toread, mSampleChunk.end(), char{});
mCurrentSample += numsamples;
return static_cast<uint32_t>(numsamples);
}
void LafStream::convertSamples(const al::span<char> samples) const
{
/* OpenAL uses unsigned 8-bit samples (0...255), so signed 8-bit samples
* (-128...+127) need conversion. The other formats are fine.
*/
if(mQuality == Quality::s8)
std::transform(samples.begin(), samples.end(), samples.begin(),
[](const char sample) noexcept { return char(sample^0x80); });
}
void LafStream::convertPositions(const al::span<float> dst, const al::span<const char> src) const
{
switch(mQuality)
{
case Quality::s8:
std::transform(src.begin(), src.end(), dst.begin(),
[](const int8_t in) { return float(in) / 127.0f; });
break;
case Quality::s16:
{
auto i16src = al::span{reinterpret_cast<const int16_t*>(src.data()),
src.size()/sizeof(int16_t)};
std::transform(i16src.begin(), i16src.end(), dst.begin(),
[](const int16_t in) { return float(in) / 32767.0f; });
}
break;
case Quality::f32:
{
auto f32src = al::span{reinterpret_cast<const float*>(src.data()),
src.size()/sizeof(float)};
std::copy(f32src.begin(), f32src.end(), dst.begin());
}
break;
case Quality::s24:
{
/* 24-bit samples are converted to 32-bit in copySamples. */
auto i32src = al::span{reinterpret_cast<const int32_t*>(src.data()),
src.size()/sizeof(int32_t)};
std::transform(i32src.begin(), i32src.end(), dst.begin(),
[](const int32_t in) { return float(in>>8) / 8388607.0f; });
}
break;
}
}
template<Quality Q>
void LafStream::copySamples(char *dst, const char *src, const size_t idx, const size_t count) const
{
using reader_t = SampleReader<Q>;
using src_t = typename reader_t::src_t;
using dst_t = typename reader_t::dst_t;
const auto step = size_t{mNumEnabled};
assert(idx < step);
auto input = al::span{reinterpret_cast<const src_t*>(src), count*step};
auto output = al::span{reinterpret_cast<dst_t*>(dst), count};
auto inptr = input.begin();
std::generate_n(output.begin(), output.size(), [&inptr,idx,step]
{
auto ret = reader_t::read(inptr[idx]);
inptr += ptrdiff_t(step);
return ret;
});
}
auto LafStream::prepareTrack(const size_t trackidx, const size_t count) -> al::span<char>
{
const auto todo = std::min(size_t{mSampleRate}, count);
if((mEnabledTracks[trackidx>>3] & (1_uz<<(trackidx&7))))
{
/* If the track is enabled, get the real index (skipping disabled
* tracks), and deinterlace it into the mono line.
*/
const auto idx = [this,trackidx]() -> unsigned int
{
const auto bits = al::span{mEnabledTracks}.first(trackidx>>3);
const auto res = std::accumulate(bits.begin(), bits.end(), 0u,
[](const unsigned int val, const uint8_t in)
{ return val + unsigned(al::popcount(unsigned(in))); });
return unsigned(al::popcount(mEnabledTracks[trackidx>>3] & ((1u<<(trackidx&7))-1)))
+ res;
}();
switch(mQuality)
{
case Quality::s8:
copySamples<Quality::s8>(mSampleLine.data(), mSampleChunk.data(), idx, todo);
break;
case Quality::s16:
copySamples<Quality::s16>(mSampleLine.data(), mSampleChunk.data(), idx, todo);
break;
case Quality::f32:
copySamples<Quality::f32>(mSampleLine.data(), mSampleChunk.data(), idx, todo);
break;
case Quality::s24:
copySamples<Quality::s24>(mSampleLine.data(), mSampleChunk.data(), idx, todo);
break;
}
}
else
{
/* If the track is disabled, provide silence. */
std::fill_n(mSampleLine.begin(), mSampleLine.size(), char{});
}
return mSampleLine.first(todo * BufferBytesFromQuality(mQuality));
}
auto LoadLAF(const fs::path &fname) -> std::unique_ptr<LafStream>
{
auto laf = std::make_unique<LafStream>();
if(!laf->mInFile.open(fname, std::ios_base::binary | std::ios_base::in))
throw std::runtime_error{"Could not open file"};
auto marker = std::array<char,9>{};
if(laf->mInFile.sgetn(marker.data(), marker.size()) != marker.size())
throw std::runtime_error{"Failed to read file marker"};
if(std::string_view{marker.data(), marker.size()} != "LIMITLESS"sv)
throw std::runtime_error{"Not an LAF file"};
auto header = std::array<char,10>{};
if(laf->mInFile.sgetn(header.data(), header.size()) != header.size())
throw std::runtime_error{"Failed to read header"};
while(std::string_view{header.data(), 4} != "HEAD"sv)
{
auto headview = std::string_view{header.data(), header.size()};
auto hiter = header.begin();
if(const auto hpos = std::min(headview.find("HEAD"sv), headview.size());
hpos < headview.size())
{
/* Found the HEAD marker. Copy what was read of the header to the
* front, fill in the rest of the header, and continue loading.
*/
hiter = std::copy(header.begin()+hpos, header.end(), hiter);
}
else if(al::ends_with(headview, "HEA"sv))
{
/* Found what might be the HEAD marker at the end. Copy it to the
* front, refill the header, and check again.
*/
hiter = std::copy_n(header.end()-3, 3, hiter);
}
else if(al::ends_with(headview, "HE"sv))
hiter = std::copy_n(header.end()-2, 2, hiter);
else if(headview.back() == 'H')
hiter = std::copy_n(header.end()-1, 1, hiter);
const auto toread = std::distance(hiter, header.end());
if(laf->mInFile.sgetn(al::to_address(hiter), toread) != toread)
throw std::runtime_error{"Failed to read header"};
}
laf->mQuality = [stype=int{header[4]}] {
if(stype == 0) return Quality::s8;
if(stype == 1) return Quality::s16;
if(stype == 2) return Quality::f32;
if(stype == 3) return Quality::s24;
throw std::runtime_error{fmt::format("Invalid quality type: {}", stype)};
}();
laf->mMode = [mode=int{header[5]}] {
if(mode == 0) return Mode::Channels;
if(mode == 1) return Mode::Objects;
throw std::runtime_error{fmt::format("Invalid mode: {}", mode)};
}();
laf->mNumTracks = [input=al::span{header}.subspan<6,4>()] {
return uint32_t{uint8_t(input[0])} | (uint32_t{uint8_t(input[1])}<<8u)
| (uint32_t{uint8_t(input[2])}<<16u) | (uint32_t{uint8_t(input[3])}<<24u);
}();
fmt::println("Filename: {}", fname.string());
fmt::println(" quality: {}", GetQualityName(laf->mQuality));
fmt::println(" mode: {}", GetModeName(laf->mMode));
fmt::println(" track count: {}", laf->mNumTracks);
if(laf->mNumTracks == 0)
throw std::runtime_error{"No tracks"};
if(laf->mNumTracks > 256)
throw std::runtime_error{fmt::format("Too many tracks: {}", laf->mNumTracks)};
auto chandata = std::vector<char>(laf->mNumTracks*9_uz);
auto headersize = std::streamsize(chandata.size());
if(laf->mInFile.sgetn(chandata.data(), headersize) != headersize)
throw std::runtime_error{"Failed to read channel header data"};
if(laf->mMode == Mode::Channels)
laf->mChannels.reserve(laf->mNumTracks);
else
{
if(laf->mNumTracks < 2)
throw std::runtime_error{"Not enough tracks"};
auto numchans = uint32_t{laf->mNumTracks - 1};
auto numpostracks = uint32_t{1};
while(numpostracks*16 < numchans)
{
--numchans;
++numpostracks;
}
laf->mChannels.reserve(numchans);
laf->mPosTracks.reserve(numpostracks);
}
for(uint32_t i{0};i < laf->mNumTracks;++i)
{
static constexpr auto read_float = [](al::span<char,4> input)
{
const auto value = uint32_t{uint8_t(input[0])} | (uint32_t{uint8_t(input[1])}<<8u)
| (uint32_t{uint8_t(input[2])}<<16u) | (uint32_t{uint8_t(input[3])}<<24u);
return al::bit_cast<float>(value);
};
auto chan = al::span{chandata}.subspan(i*9_uz, 9);
auto x_axis = read_float(chan.first<4>());
auto y_axis = read_float(chan.subspan<4,4>());
auto lfe_flag = int{chan[8]};
fmt::println("Track {}: E={:f}, A={:f} (LFE: {})", i, x_axis, y_axis, lfe_flag);
if(x_axis != x_axis && y_axis == 0.0)
{
MyAssert(laf->mMode == Mode::Objects);
MyAssert(i != 0);
laf->mPosTracks.emplace_back();
}
else
{
MyAssert(laf->mPosTracks.empty());
MyAssert(std::isfinite(x_axis) && std::isfinite(y_axis));
auto &channel = laf->mChannels.emplace_back();
channel.mAzimuth = y_axis;
channel.mElevation = x_axis;
channel.mIsLfe = lfe_flag != 0;
}
}
fmt::println("Channels: {}", laf->mChannels.size());
/* For "objects" mode, ensure there's enough tracks with position data to
* handle the audio channels.
*/
if(laf->mMode == Mode::Objects)
MyAssert(((laf->mChannels.size()-1)>>4) == laf->mPosTracks.size()-1);
auto footer = std::array<char,12>{};
if(laf->mInFile.sgetn(footer.data(), footer.size()) != footer.size())
throw std::runtime_error{"Failed to read sample header data"};
laf->mSampleRate = [input=al::span{footer}.first<4>()] {
return uint32_t{uint8_t(input[0])} | (uint32_t{uint8_t(input[1])}<<8u)
| (uint32_t{uint8_t(input[2])}<<16u) | (uint32_t{uint8_t(input[3])}<<24u);
}();
laf->mSampleCount = [input=al::span{footer}.last<8>()] {
return uint64_t{uint8_t(input[0])} | (uint64_t{uint8_t(input[1])}<<8)
| (uint64_t{uint8_t(input[2])}<<16u) | (uint64_t{uint8_t(input[3])}<<24u)
| (uint64_t{uint8_t(input[4])}<<32u) | (uint64_t{uint8_t(input[5])}<<40u)
| (uint64_t{uint8_t(input[6])}<<48u) | (uint64_t{uint8_t(input[7])}<<56u);
}();
fmt::println("Sample rate: {}", laf->mSampleRate);
fmt::println("Length: {} samples ({:.2f} sec)", laf->mSampleCount,
static_cast<double>(laf->mSampleCount)/static_cast<double>(laf->mSampleRate));
/* Position vectors get split across the PCM chunks if the sample rate
* isn't a multiple of 48. Each PCM chunk is exactly one second (the sample
* rate in sample frames). Each track with position data consists of a set
* of 3 samples for 16 audio channels, resuling in 48 sample frames for a
* full set of positions. Extra logic will be needed to manage the position
* frame offset separate from each chunk.
*/
MyAssert(laf->mMode == Mode::Channels || (laf->mSampleRate%FramesPerPos) == 0);
for(size_t i{0};i < laf->mPosTracks.size();++i)
laf->mPosTracks[i].resize(laf->mSampleRate*2_uz, 0.0f);
laf->mSampleChunk.resize(laf->mSampleRate*BytesFromQuality(laf->mQuality)*laf->mNumTracks
+ laf->mSampleRate*BufferBytesFromQuality(laf->mQuality));
laf->mSampleLine = al::span{laf->mSampleChunk}.last(laf->mSampleRate
* BufferBytesFromQuality(laf->mQuality));
return laf;
}
void PlayLAF(std::string_view fname)
try {
auto laf = LoadLAF(fs::u8path(fname));
switch(laf->mQuality)
{
case Quality::s8:
laf->mALFormat = AL_FORMAT_MONO8;
break;
case Quality::s16:
laf->mALFormat = AL_FORMAT_MONO16;
break;
case Quality::f32:
if(alIsExtensionPresent("AL_EXT_FLOAT32"))
laf->mALFormat = AL_FORMAT_MONO_FLOAT32;
break;
case Quality::s24:
laf->mALFormat = alGetEnumValue("AL_FORMAT_MONO32");
if(!laf->mALFormat || laf->mALFormat == -1)
laf->mALFormat = alGetEnumValue("AL_FORMAT_MONO_I32");
break;
}
if(!laf->mALFormat || laf->mALFormat == -1)
throw std::runtime_error{fmt::format("No supported format for {} samples",
GetQualityName(laf->mQuality))};
static constexpr auto alloc_channel = [](Channel &channel)
{
alGenSources(1, &channel.mSource);
alGenBuffers(ALsizei(channel.mBuffers.size()), channel.mBuffers.data());
/* Disable distance attenuation, and make sure the source stays locked
* relative to the listener.
*/
alSourcef(channel.mSource, AL_ROLLOFF_FACTOR, 0.0f);
alSourcei(channel.mSource, AL_SOURCE_RELATIVE, AL_TRUE);
/* FIXME: Is the Y rotation/azimuth clockwise or counter-clockwise?
* Does +azimuth move a front sound right or left?
*/
const auto x = std::sin(channel.mAzimuth) * std::cos(channel.mElevation);
const auto y = std::sin(channel.mElevation);
const auto z = -std::cos(channel.mAzimuth) * std::cos(channel.mElevation);
alSource3f(channel.mSource, AL_POSITION, x, y, z);
if(channel.mIsLfe)
{
if(LfeSlotID)
{
/* For LFE, silence the direct/dry path and connect the LFE aux
* slot on send 0.
*/
alSourcei(channel.mSource, AL_DIRECT_FILTER, ALint(MuteFilterID));
alSource3i(channel.mSource, AL_AUXILIARY_SEND_FILTER, ALint(LfeSlotID), 0,
AL_FILTER_NULL);
}
else
{
/* If AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT isn't available,
* silence LFE channels since they may not be appropriate to
* play normally.
*/
alSourcef(channel.mSource, AL_GAIN, 0.0f);
}
}
if(auto err=alGetError())
throw std::runtime_error{fmt::format("OpenAL error: {}", alGetString(err))};
};
std::for_each(laf->mChannels.begin(), laf->mChannels.end(), alloc_channel);
while(!laf->isAtEnd())
{
auto state = ALenum{};
auto offset = ALint{};
auto processed = ALint{};
/* All sources are played in sync, so they'll all be at the same offset
* with the same state and number of processed buffers. Query the back
* source just in case the previous update ran really late and missed
* updating only some sources on time (in which case, the latter ones
* will underrun, which this will detect and restart them all as
* needed).
*/
alGetSourcei(laf->mChannels.back().mSource, AL_BUFFERS_PROCESSED, &processed);
alGetSourcei(laf->mChannels.back().mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(laf->mChannels.back().mSource, AL_SOURCE_STATE, &state);
if(state == AL_PLAYING || state == AL_PAUSED)
{
if(!laf->mPosTracks.empty())
{
alcSuspendContext(alcGetCurrentContext());
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto trackidx = i>>4;
const auto posoffset = unsigned(offset)/FramesPerPos*16_uz + (i&15);
const auto x = laf->mPosTracks[trackidx][posoffset*3 + 0];
const auto y = laf->mPosTracks[trackidx][posoffset*3 + 1];
const auto z = laf->mPosTracks[trackidx][posoffset*3 + 2];
/* Contrary to the docs, the position is left-handed and
* needs to be converted to right-handed.
*/
alSource3f(laf->mChannels[i].mSource, AL_POSITION, x, y, -z);
}
alcProcessContext(alcGetCurrentContext());
}
if(processed > 0)
{
const auto numsamples = laf->readChunk();
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto samples = laf->prepareTrack(i, numsamples);
laf->convertSamples(samples);
auto bufid = ALuint{};
alSourceUnqueueBuffers(laf->mChannels[i].mSource, 1, &bufid);
alBufferData(bufid, laf->mALFormat, samples.data(), ALsizei(samples.size()),
ALsizei(laf->mSampleRate));
alSourceQueueBuffers(laf->mChannels[i].mSource, 1, &bufid);
}
for(size_t i{0};i < laf->mPosTracks.size();++i)
{
std::copy(laf->mPosTracks[i].begin() + ptrdiff_t(laf->mSampleRate),
laf->mPosTracks[i].end(), laf->mPosTracks[i].begin());
const auto positions = laf->prepareTrack(laf->mChannels.size()+i, numsamples);
laf->convertPositions(al::span{laf->mPosTracks[i]}.last(laf->mSampleRate),
positions);
}
}
else
std::this_thread::sleep_for(std::chrono::milliseconds{10});
}
else if(state == AL_STOPPED)
{
auto sources = std::array<ALuint,256>{};
for(size_t i{0};i < laf->mChannels.size();++i)
sources[i] = laf->mChannels[i].mSource;
alSourcePlayv(ALsizei(laf->mChannels.size()), sources.data());
}
else if(state == AL_INITIAL)
{
auto sources = std::array<ALuint,256>{};
auto numsamples = laf->readChunk();
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto samples = laf->prepareTrack(i, numsamples);
laf->convertSamples(samples);
alBufferData(laf->mChannels[i].mBuffers[0], laf->mALFormat, samples.data(),
ALsizei(samples.size()), ALsizei(laf->mSampleRate));
}
for(size_t i{0};i < laf->mPosTracks.size();++i)
{
const auto positions = laf->prepareTrack(laf->mChannels.size()+i, numsamples);
laf->convertPositions(al::span{laf->mPosTracks[i]}.first(laf->mSampleRate),
positions);
}
numsamples = laf->readChunk();
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto samples = laf->prepareTrack(i, numsamples);
laf->convertSamples(samples);
alBufferData(laf->mChannels[i].mBuffers[1], laf->mALFormat, samples.data(),
ALsizei(samples.size()), ALsizei(laf->mSampleRate));
alSourceQueueBuffers(laf->mChannels[i].mSource,
ALsizei(laf->mChannels[i].mBuffers.size()), laf->mChannels[i].mBuffers.data());
sources[i] = laf->mChannels[i].mSource;
}
for(size_t i{0};i < laf->mPosTracks.size();++i)
{
const auto positions = laf->prepareTrack(laf->mChannels.size()+i, numsamples);
laf->convertPositions(al::span{laf->mPosTracks[i]}.last(laf->mSampleRate),
positions);
}
if(!laf->mPosTracks.empty())
{
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto trackidx = i>>4;
const auto x = laf->mPosTracks[trackidx][(i&15)*3 + 0];
const auto y = laf->mPosTracks[trackidx][(i&15)*3 + 1];
const auto z = laf->mPosTracks[trackidx][(i&15)*3 + 2];
alSource3f(laf->mChannels[i].mSource, AL_POSITION, x, y, -z);
}
}
alSourcePlayv(ALsizei(laf->mChannels.size()), sources.data());
}
else
break;
}
auto state = ALenum{};
auto offset = ALint{};
alGetSourcei(laf->mChannels.back().mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(laf->mChannels.back().mSource, AL_SOURCE_STATE, &state);
while(alGetError() == AL_NO_ERROR && state == AL_PLAYING)
{
if(!laf->mPosTracks.empty())
{
alcSuspendContext(alcGetCurrentContext());
for(size_t i{0};i < laf->mChannels.size();++i)
{
const auto trackidx = i>>4;
const auto posoffset = unsigned(offset)/FramesPerPos*16_uz + (i&15);
const auto x = laf->mPosTracks[trackidx][posoffset*3 + 0];
const auto y = laf->mPosTracks[trackidx][posoffset*3 + 1];
const auto z = laf->mPosTracks[trackidx][posoffset*3 + 2];
alSource3f(laf->mChannels[i].mSource, AL_POSITION, x, y, -z);
}
alcProcessContext(alcGetCurrentContext());
}
std::this_thread::sleep_for(std::chrono::milliseconds{10});
alGetSourcei(laf->mChannels.back().mSource, AL_SAMPLE_OFFSET, &offset);
alGetSourcei(laf->mChannels.back().mSource, AL_SOURCE_STATE, &state);
}
}
catch(std::exception& e) {
fmt::println(stderr, "Error playing {}:\n {}", fname, e.what());
}
auto main(al::span<std::string_view> args) -> int
{
/* Print out usage if no arguments were specified */
if(args.size() < 2)
{
fmt::println(stderr, "Usage: {} [-device <name>] <filenames...>\n", args[0]);
return 1;
}
args = args.subspan(1);
if(InitAL(args) != 0)
throw std::runtime_error{"Failed to initialize OpenAL"};
/* A simple RAII container for automating OpenAL shutdown. */
struct AudioManager {
AudioManager() = default;
AudioManager(const AudioManager&) = delete;
auto operator=(const AudioManager&) -> AudioManager& = delete;
~AudioManager()
{
if(LfeSlotID)
{
alDeleteAuxiliaryEffectSlots(1, &LfeSlotID);
alDeleteEffects(1, &LowFrequencyEffectID);
alDeleteFilters(1, &MuteFilterID);
}
CloseAL();
}
};
AudioManager almgr;
if(auto *device = alcGetContextsDevice(alcGetCurrentContext());
alcIsExtensionPresent(device, "ALC_EXT_EFX")
&& alcIsExtensionPresent(device, "ALC_EXT_DEDICATED"))
{
#define LOAD_PROC(x) do { \
x = reinterpret_cast<decltype(x)>(alGetProcAddress(#x)); \
if(!x) fmt::println(stderr, "Failed to find function '{}'\n", #x##sv);\
} while(0)
LOAD_PROC(alGenFilters);
LOAD_PROC(alDeleteFilters);
LOAD_PROC(alIsFilter);
LOAD_PROC(alFilterf);
LOAD_PROC(alFilterfv);
LOAD_PROC(alFilteri);
LOAD_PROC(alFilteriv);
LOAD_PROC(alGetFilterf);
LOAD_PROC(alGetFilterfv);
LOAD_PROC(alGetFilteri);
LOAD_PROC(alGetFilteriv);
LOAD_PROC(alGenEffects);
LOAD_PROC(alDeleteEffects);
LOAD_PROC(alIsEffect);
LOAD_PROC(alEffectf);
LOAD_PROC(alEffectfv);
LOAD_PROC(alEffecti);
LOAD_PROC(alEffectiv);
LOAD_PROC(alGetEffectf);
LOAD_PROC(alGetEffectfv);
LOAD_PROC(alGetEffecti);
LOAD_PROC(alGetEffectiv);
LOAD_PROC(alGenAuxiliaryEffectSlots);
LOAD_PROC(alDeleteAuxiliaryEffectSlots);
LOAD_PROC(alIsAuxiliaryEffectSlot);
LOAD_PROC(alAuxiliaryEffectSlotf);
LOAD_PROC(alAuxiliaryEffectSlotfv);
LOAD_PROC(alAuxiliaryEffectSloti);
LOAD_PROC(alAuxiliaryEffectSlotiv);
LOAD_PROC(alGetAuxiliaryEffectSlotf);
LOAD_PROC(alGetAuxiliaryEffectSlotfv);
LOAD_PROC(alGetAuxiliaryEffectSloti);
LOAD_PROC(alGetAuxiliaryEffectSlotiv);
#undef LOAD_PROC
alGenFilters(1, &MuteFilterID);
alFilteri(MuteFilterID, AL_FILTER_TYPE, AL_FILTER_LOWPASS);
alFilterf(MuteFilterID, AL_LOWPASS_GAIN, 0.0f);
MyAssert(alGetError() == AL_NO_ERROR);
alGenEffects(1, &LowFrequencyEffectID);
alEffecti(LowFrequencyEffectID, AL_EFFECT_TYPE, AL_EFFECT_DEDICATED_LOW_FREQUENCY_EFFECT);
MyAssert(alGetError() == AL_NO_ERROR);
alGenAuxiliaryEffectSlots(1, &LfeSlotID);
alAuxiliaryEffectSloti(LfeSlotID, AL_EFFECTSLOT_EFFECT, ALint(LowFrequencyEffectID));
MyAssert(alGetError() == AL_NO_ERROR);
}
std::for_each(args.begin(), args.end(), PlayLAF);
return 0;
}
} // namespace
int main(int argc, char **argv)
{
MyAssert(argc >= 0);
auto args = std::vector<std::string_view>(static_cast<unsigned int>(argc));
std::copy_n(argv, args.size(), args.begin());
return main(al::span{args});
}
Reference in a new issue View git blame Copy permalink