Much more clang-tidy cleanup

9 files changed, 299 insertions, 310 deletions

diff --git a/utils/alsoft-config/mainwindow.h b/utils/alsoft-config/mainwindow.h
index f7af8eac..e2d30b86 100644
--- a/utils/alsoft-config/mainwindow.h
+++ b/utils/alsoft-config/mainwindow.h
@@ -8,13 +8,12 @@ namespace Ui {
 class MainWindow;
 }
 
-class MainWindow : public QMainWindow
-{
+class MainWindow : public QMainWindow {
     Q_OBJECT
 
 public:
-    explicit MainWindow(QWidget *parent = 0);
-    ~MainWindow();
+    explicit MainWindow(QWidget *parent=nullptr);
+    ~MainWindow() override;
 
 private slots:
     void cancelCloseAction();
@@ -63,17 +62,17 @@ private slots:
 private:
     Ui::MainWindow *ui;
 
-    QValidator *mPeriodSizeValidator;
-    QValidator *mPeriodCountValidator;
-    QValidator *mSourceCountValidator;
-    QValidator *mEffectSlotValidator;
-    QValidator *mSourceSendValidator;
-    QValidator *mSampleRateValidator;
-    QValidator *mJackBufferValidator;
+    QValidator *mPeriodSizeValidator{};
+    QValidator *mPeriodCountValidator{};
+    QValidator *mSourceCountValidator{};
+    QValidator *mEffectSlotValidator{};
+    QValidator *mSourceSendValidator{};
+    QValidator *mSampleRateValidator{};
+    QValidator *mJackBufferValidator{};
 
-    bool mNeedsSave;
+    bool mNeedsSave{};
 
-    void closeEvent(QCloseEvent *event);
+    void closeEvent(QCloseEvent *event) override;
 
     void selectDecoderFile(QLineEdit *line, const char *name);
 
diff --git a/utils/makemhr/loaddef.cpp b/utils/makemhr/loaddef.cpp
index c8a98511..54ba96a3 100644
--- a/utils/makemhr/loaddef.cpp
+++ b/utils/makemhr/loaddef.cpp
@@ -36,6 +36,7 @@
 #include <optional>
 #include <vector>
 
+#include "albit.h"
 #include "alfstream.h"
 #include "alspan.h"
 #include "alstring.h"
@@ -144,7 +145,7 @@ struct SourceRefT {
     double mRadius;
     uint mSkip;
     uint mOffset;
-    char mPath[MAX_PATH_LEN+1];
+    std::array<char,MAX_PATH_LEN+1> mPath;
 };
 
 
@@ -389,22 +390,20 @@ static int TrReadIdent(TokenReaderT *tr, const uint maxLen, char *ident)
 // Reads and validates (including bounds) an integer token.
 static int TrReadInt(TokenReaderT *tr, const int loBound, const int hiBound, int *value)
 {
-    uint col, digis, len;
-    char ch, temp[64+1];
-
-    col = tr->mColumn;
+    uint col{tr->mColumn};
     if(TrSkipWhitespace(tr))
     {
         col = tr->mColumn;
-        len = 0;
-        ch = tr->mRing[tr->mOut&TR_RING_MASK];
+        uint len{0};
+        std::array<char,64+1> temp{};
+        char ch{tr->mRing[tr->mOut&TR_RING_MASK]};
         if(ch == '+' || ch == '-')
         {
             temp[len] = ch;
             len++;
             tr->mOut++;
         }
-        digis = 0;
+        uint digis{0};
         while(TrLoad(tr))
         {
             ch = tr->mRing[tr->mOut&TR_RING_MASK];
@@ -424,7 +423,7 @@ static int TrReadInt(TokenReaderT *tr, const int loBound, const int hiBound, int
                 return 0;
             }
             temp[len] = '\0';
-            *value = static_cast<int>(strtol(temp, nullptr, 10));
+            *value = static_cast<int>(strtol(temp.data(), nullptr, 10));
             if(*value < loBound || *value > hiBound)
             {
                 TrErrorAt(tr, tr->mLine, col, "Expected a value from %d to %d.\n", loBound, hiBound);
@@ -440,15 +439,13 @@ static int TrReadInt(TokenReaderT *tr, const int loBound, const int hiBound, int
 // Reads and validates (including bounds) a float token.
 static int TrReadFloat(TokenReaderT *tr, const double loBound, const double hiBound, double *value)
 {
-    uint col, digis, len;
-    char ch, temp[64+1];
-
-    col = tr->mColumn;
+    uint col{tr->mColumn};
     if(TrSkipWhitespace(tr))
     {
         col = tr->mColumn;
-        len = 0;
-        ch = tr->mRing[tr->mOut&TR_RING_MASK];
+        std::array<char,64+1> temp{};
+        uint len{0};
+        char ch{tr->mRing[tr->mOut&TR_RING_MASK]};
         if(ch == '+' || ch == '-')
         {
             temp[len] = ch;
@@ -456,7 +453,7 @@ static int TrReadFloat(TokenReaderT *tr, const double loBound, const double hiBo
             tr->mOut++;
         }
 
-        digis = 0;
+        uint digis{0};
         while(TrLoad(tr))
         {
             ch = tr->mRing[tr->mOut&TR_RING_MASK];
@@ -520,7 +517,7 @@ static int TrReadFloat(TokenReaderT *tr, const double loBound, const double hiBo
                     return 0;
                 }
                 temp[len] = '\0';
-                *value = strtod(temp, nullptr);
+                *value = strtod(temp.data(), nullptr);
                 if(*value < loBound || *value > hiBound)
                 {
                     TrErrorAt(tr, tr->mLine, col, "Expected a value from %f to %f.\n", loBound, hiBound);
@@ -621,8 +618,8 @@ static int TrReadOperator(TokenReaderT *tr, const char *op)
 // storing it as a 32-bit unsigned integer.
 static int ReadBin4(std::istream &istream, const char *filename, const ByteOrderT order, const uint bytes, uint32_t *out)
 {
-    uint8_t in[4];
-    istream.read(reinterpret_cast<char*>(in), static_cast<int>(bytes));
+    std::array<uint8_t,4> in{};
+    istream.read(reinterpret_cast<char*>(in.data()), static_cast<int>(bytes));
     if(istream.gcount() != bytes)
     {
         fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
@@ -650,29 +647,27 @@ static int ReadBin4(std::istream &istream, const char *filename, const ByteOrder
 // a 64-bit unsigned integer.
 static int ReadBin8(std::istream &istream, const char *filename, const ByteOrderT order, uint64_t *out)
 {
-    uint8_t in[8];
-    uint64_t accum;
-    uint i;
-
-    istream.read(reinterpret_cast<char*>(in), 8);
+    std::array<uint8_t,8> in{};
+    istream.read(reinterpret_cast<char*>(in.data()), 8);
     if(istream.gcount() != 8)
     {
         fprintf(stderr, "\nError: Bad read from file '%s'.\n", filename);
         return 0;
     }
-    accum = 0;
+
+    uint64_t accum{};
     switch(order)
     {
-        case BO_LITTLE:
-            for(i = 0;i < 8;i++)
-                accum = (accum<<8) | in[8 - i - 1];
-            break;
-        case BO_BIG:
-            for(i = 0;i < 8;i++)
-                accum = (accum<<8) | in[i];
-            break;
-        default:
-            break;
+    case BO_LITTLE:
+        for(uint i{0};i < 8;++i)
+            accum = (accum<<8) | in[8 - i - 1];
+        break;
+    case BO_BIG:
+        for(uint i{0};i < 8;++i)
+            accum = (accum<<8) | in[i];
+        break;
+    default:
+        break;
     }
     *out = accum;
     return 1;
@@ -687,40 +682,32 @@ static int ReadBin8(std::istream &istream, const char *filename, const ByteOrder
 static int ReadBinAsDouble(std::istream &istream, const char *filename, const ByteOrderT order,
     const ElementTypeT type, const uint bytes, const int bits, double *out)
 {
-    union {
-        uint32_t ui;
-        int32_t i;
-        float f;
-    } v4;
-    union {
-        uint64_t ui;
-        double f;
-    } v8;
-
     *out = 0.0;
     if(bytes > 4)
     {
-        if(!ReadBin8(istream, filename, order, &v8.ui))
+        uint64_t val{};
+        if(!ReadBin8(istream, filename, order, &val))
             return 0;
         if(type == ET_FP)
-            *out = v8.f;
+            *out = al::bit_cast<double>(val);
     }
     else
     {
-        if(!ReadBin4(istream, filename, order, bytes, &v4.ui))
+        uint32_t val{};
+        if(!ReadBin4(istream, filename, order, bytes, &val))
             return 0;
         if(type == ET_FP)
-            *out = v4.f;
+            *out = al::bit_cast<float>(val);
         else
         {
             if(bits > 0)
-                v4.ui >>= (8*bytes) - (static_cast<uint>(bits));
+                val >>= (8*bytes) - (static_cast<uint>(bits));
             else
-                v4.ui &= (0xFFFFFFFF >> (32+bits));
+                val &= (0xFFFFFFFF >> (32+bits));
 
-            if(v4.ui&static_cast<uint>(1<<(std::abs(bits)-1)))
-                v4.ui |= (0xFFFFFFFF << std::abs(bits));
-            *out = v4.i / static_cast<double>(1<<(std::abs(bits)-1));
+            if(val&static_cast<uint>(1<<(std::abs(bits)-1)))
+                val |= (0xFFFFFFFF << std::abs(bits));
+            *out = static_cast<int32_t>(val) / static_cast<double>(1<<(std::abs(bits)-1));
         }
     }
     return 1;
@@ -776,20 +763,20 @@ static int ReadWaveFormat(std::istream &istream, const ByteOrderT order, const u
     do {
         if(chunkSize > 0)
             istream.seekg(static_cast<int>(chunkSize), std::ios::cur);
-        if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
-            || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
+        if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC)
+            || !ReadBin4(istream, src->mPath.data(), order, 4, &chunkSize))
             return 0;
     } while(fourCC != FOURCC_FMT);
-    if(!ReadBin4(istream, src->mPath, order, 2, &format)
-        || !ReadBin4(istream, src->mPath, order, 2, &channels)
-        || !ReadBin4(istream, src->mPath, order, 4, &rate)
-        || !ReadBin4(istream, src->mPath, order, 4, &dummy)
-        || !ReadBin4(istream, src->mPath, order, 2, &block))
+    if(!ReadBin4(istream, src->mPath.data(), order, 2, &format)
+        || !ReadBin4(istream, src->mPath.data(), order, 2, &channels)
+        || !ReadBin4(istream, src->mPath.data(), order, 4, &rate)
+        || !ReadBin4(istream, src->mPath.data(), order, 4, &dummy)
+        || !ReadBin4(istream, src->mPath.data(), order, 2, &block))
         return 0;
     block /= channels;
     if(chunkSize > 14)
     {
-        if(!ReadBin4(istream, src->mPath, order, 2, &size))
+        if(!ReadBin4(istream, src->mPath.data(), order, 2, &size))
             return 0;
         size /= 8;
         if(block > size)
@@ -800,12 +787,12 @@ static int ReadWaveFormat(std::istream &istream, const ByteOrderT order, const u
     if(format == WAVE_FORMAT_EXTENSIBLE)
     {
         istream.seekg(2, std::ios::cur);
-        if(!ReadBin4(istream, src->mPath, order, 2, &bits))
+        if(!ReadBin4(istream, src->mPath.data(), order, 2, &bits))
             return 0;
         if(bits == 0)
             bits = 8 * size;
         istream.seekg(4, std::ios::cur);
-        if(!ReadBin4(istream, src->mPath, order, 2, &format))
+        if(!ReadBin4(istream, src->mPath.data(), order, 2, &format))
             return 0;
         istream.seekg(static_cast<int>(chunkSize - 26), std::ios::cur);
     }
@@ -819,29 +806,32 @@ static int ReadWaveFormat(std::istream &istream, const ByteOrderT order, const u
     }
     if(format != WAVE_FORMAT_PCM && format != WAVE_FORMAT_IEEE_FLOAT)
     {
-        fprintf(stderr, "\nError: Unsupported WAVE format in file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Unsupported WAVE format in file '%s'.\n", src->mPath.data());
         return 0;
     }
     if(src->mChannel >= channels)
     {
-        fprintf(stderr, "\nError: Missing source channel in WAVE file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Missing source channel in WAVE file '%s'.\n", src->mPath.data());
         return 0;
     }
     if(rate != hrirRate)
     {
-        fprintf(stderr, "\nError: Mismatched source sample rate in WAVE file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Mismatched source sample rate in WAVE file '%s'.\n",
+            src->mPath.data());
         return 0;
     }
     if(format == WAVE_FORMAT_PCM)
     {
         if(size < 2 || size > 4)
         {
-            fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n", src->mPath);
+            fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n",
+                src->mPath.data());
             return 0;
         }
         if(bits < 16 || bits > (8*size))
         {
-            fprintf(stderr, "\nError: Bad significant bits in WAVE file '%s'.\n", src->mPath);
+            fprintf(stderr, "\nError: Bad significant bits in WAVE file '%s'.\n",
+                src->mPath.data());
             return 0;
         }
         src->mType = ET_INT;
@@ -850,7 +840,8 @@ static int ReadWaveFormat(std::istream &istream, const ByteOrderT order, const u
     {
         if(size != 4 && size != 8)
         {
-            fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n", src->mPath);
+            fprintf(stderr, "\nError: Unsupported sample size in WAVE file '%s'.\n",
+                src->mPath.data());
             return 0;
         }
         src->mType = ET_FP;
@@ -876,7 +867,8 @@ static int ReadWaveData(std::istream &istream, const SourceRefT *src, const Byte
         skip += pre;
         if(skip > 0)
             istream.seekg(skip, std::ios::cur);
-        if(!ReadBinAsDouble(istream, src->mPath, order, src->mType, src->mSize, src->mBits, &hrir[i]))
+        if(!ReadBinAsDouble(istream, src->mPath.data(), order, src->mType, src->mSize, src->mBits,
+            &hrir[i]))
             return 0;
         skip = post;
     }
@@ -896,8 +888,8 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
 
     for(;;)
     {
-        if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
-            || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
+        if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC)
+            || !ReadBin4(istream, src->mPath.data(), order, 4, &chunkSize))
             return 0;
 
         if(fourCC == FOURCC_DATA)
@@ -906,7 +898,7 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
             count = chunkSize / block;
             if(count < (src->mOffset + n))
             {
-                fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath);
+                fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath.data());
                 return 0;
             }
             istream.seekg(static_cast<long>(src->mOffset * block), std::ios::cur);
@@ -916,7 +908,7 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
         }
         else if(fourCC == FOURCC_LIST)
         {
-            if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC))
+            if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC))
                 return 0;
             chunkSize -= 4;
             if(fourCC == FOURCC_WAVL)
@@ -932,8 +924,8 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
     lastSample = 0.0;
     while(offset < n && listSize > 8)
     {
-        if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
-            || !ReadBin4(istream, src->mPath, order, 4, &chunkSize))
+        if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC)
+            || !ReadBin4(istream, src->mPath.data(), order, 4, &chunkSize))
             return 0;
         listSize -= 8 + chunkSize;
         if(fourCC == FOURCC_DATA)
@@ -961,7 +953,7 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
         }
         else if(fourCC == FOURCC_SLNT)
         {
-            if(!ReadBin4(istream, src->mPath, order, 4, &count))
+            if(!ReadBin4(istream, src->mPath.data(), order, 4, &count))
                 return 0;
             chunkSize -= 4;
             if(count > skip)
@@ -985,7 +977,7 @@ static int ReadWaveList(std::istream &istream, const SourceRefT *src, const Byte
     }
     if(offset < n)
     {
-        fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Bad read from file '%s'.\n", src->mPath.data());
         return 0;
     }
     return 1;
@@ -997,22 +989,25 @@ static int LoadAsciiSource(std::istream &istream, const SourceRefT *src,
     const uint n, double *hrir)
 {
     TokenReaderT tr{istream};
-    uint i, j;
-    double dummy;
 
     TrSetup(nullptr, 0, nullptr, &tr);
-    for(i = 0;i < src->mOffset;i++)
+    for(uint i{0};i < src->mOffset;++i)
     {
-        if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &dummy))
+        double dummy{};
+        if(!ReadAsciiAsDouble(&tr, src->mPath.data(), src->mType, static_cast<uint>(src->mBits),
+            &dummy))
             return 0;
     }
-    for(i = 0;i < n;i++)
+    for(uint i{0};i < n;++i)
     {
-        if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &hrir[i]))
+        if(!ReadAsciiAsDouble(&tr, src->mPath.data(), src->mType, static_cast<uint>(src->mBits),
+            &hrir[i]))
             return 0;
-        for(j = 0;j < src->mSkip;j++)
+        for(uint j{0};j < src->mSkip;++j)
         {
-            if(!ReadAsciiAsDouble(&tr, src->mPath, src->mType, static_cast<uint>(src->mBits), &dummy))
+            double dummy{};
+            if(!ReadAsciiAsDouble(&tr, src->mPath.data(), src->mType,
+                static_cast<uint>(src->mBits), &dummy))
                 return 0;
         }
     }
@@ -1026,7 +1021,8 @@ static int LoadBinarySource(std::istream &istream, const SourceRefT *src, const
     istream.seekg(static_cast<long>(src->mOffset), std::ios::beg);
     for(uint i{0};i < n;i++)
     {
-        if(!ReadBinAsDouble(istream, src->mPath, order, src->mType, src->mSize, src->mBits, &hrir[i]))
+        if(!ReadBinAsDouble(istream, src->mPath.data(), order, src->mType, src->mSize, src->mBits,
+            &hrir[i]))
             return 0;
         if(src->mSkip > 0)
             istream.seekg(static_cast<long>(src->mSkip), std::ios::cur);
@@ -1041,8 +1037,8 @@ static int LoadWaveSource(std::istream &istream, SourceRefT *src, const uint hri
     uint32_t fourCC, dummy;
     ByteOrderT order;
 
-    if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC)
-        || !ReadBin4(istream, src->mPath, BO_LITTLE, 4, &dummy))
+    if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC)
+        || !ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &dummy))
         return 0;
     if(fourCC == FOURCC_RIFF)
         order = BO_LITTLE;
@@ -1050,15 +1046,15 @@ static int LoadWaveSource(std::istream &istream, SourceRefT *src, const uint hri
         order = BO_BIG;
     else
     {
-        fprintf(stderr, "\nError: No RIFF/RIFX chunk in file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: No RIFF/RIFX chunk in file '%s'.\n", src->mPath.data());
         return 0;
     }
 
-    if(!ReadBin4(istream, src->mPath, BO_LITTLE, 4, &fourCC))
+    if(!ReadBin4(istream, src->mPath.data(), BO_LITTLE, 4, &fourCC))
         return 0;
     if(fourCC != FOURCC_WAVE)
     {
-        fprintf(stderr, "\nError: Not a RIFF/RIFX WAVE file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Not a RIFF/RIFX WAVE file '%s'.\n", src->mPath.data());
         return 0;
     }
     if(!ReadWaveFormat(istream, order, hrirRate, src))
@@ -1073,7 +1069,7 @@ static int LoadWaveSource(std::istream &istream, SourceRefT *src, const uint hri
 // Load a Spatially Oriented Format for Accoustics (SOFA) file.
 static MYSOFA_EASY* LoadSofaFile(SourceRefT *src, const uint hrirRate, const uint n)
 {
-    struct MYSOFA_EASY *sofa{mysofa_cache_lookup(src->mPath, static_cast<float>(hrirRate))};
+    MYSOFA_EASY *sofa{mysofa_cache_lookup(src->mPath.data(), static_cast<float>(hrirRate))};
     if(sofa) return sofa;
 
     sofa = static_cast<MYSOFA_EASY*>(calloc(1, sizeof(*sofa)));
@@ -1086,27 +1082,27 @@ static MYSOFA_EASY* LoadSofaFile(SourceRefT *src, const uint hrirRate, const uin
     sofa->neighborhood = nullptr;
 
     int err;
-    sofa->hrtf = mysofa_load(src->mPath, &err);
+    sofa->hrtf = mysofa_load(src->mPath.data(), &err);
     if(!sofa->hrtf)
     {
         mysofa_close(sofa);
-        fprintf(stderr, "\nError: Could not load source file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Could not load source file '%s'.\n", src->mPath.data());
         return nullptr;
     }
     /* NOTE: Some valid SOFA files are failing this check. */
     err = mysofa_check(sofa->hrtf);
     if(err != MYSOFA_OK)
-        fprintf(stderr, "\nWarning: Supposedly malformed source file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nWarning: Supposedly malformed source file '%s'.\n", src->mPath.data());
     if((src->mOffset + n) > sofa->hrtf->N)
     {
         mysofa_close(sofa);
-        fprintf(stderr, "\nError: Not enough samples in SOFA file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Not enough samples in SOFA file '%s'.\n", src->mPath.data());
         return nullptr;
     }
     if(src->mChannel >= sofa->hrtf->R)
     {
         mysofa_close(sofa);
-        fprintf(stderr, "\nError: Missing source receiver in SOFA file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Missing source receiver in SOFA file '%s'.\n",src->mPath.data());
         return nullptr;
     }
     mysofa_tocartesian(sofa->hrtf);
@@ -1117,7 +1113,7 @@ static MYSOFA_EASY* LoadSofaFile(SourceRefT *src, const uint hrirRate, const uin
         fprintf(stderr, "\nError:  Out of memory.\n");
         return nullptr;
     }
-    return mysofa_cache_store(sofa, src->mPath, static_cast<float>(hrirRate));
+    return mysofa_cache_store(sofa, src->mPath.data(), static_cast<float>(hrirRate));
 }
 
 // Copies the HRIR data from a particular SOFA measurement.
@@ -1131,40 +1127,39 @@ static void ExtractSofaHrir(const MYSOFA_EASY *sofa, const uint index, const uin
 // file.
 static int LoadSofaSource(SourceRefT *src, const uint hrirRate, const uint n, double *hrir)
 {
-    struct MYSOFA_EASY *sofa;
-    float target[3];
-    int nearest;
-    float *coords;
+    MYSOFA_EASY *sofa{LoadSofaFile(src, hrirRate, n)};
+    if(sofa == nullptr) return 0;
 
-    sofa = LoadSofaFile(src, hrirRate, n);
-    if(sofa == nullptr)
-        return 0;
-
-    /* NOTE: At some point it may be benficial or necessary to consider the
+    /* NOTE: At some point it may be beneficial or necessary to consider the
              various coordinate systems, listener/source orientations, and
-             direciontal vectors defined in the SOFA file.
+             directional vectors defined in the SOFA file.
     */
-    target[0] = static_cast<float>(src->mAzimuth);
-    target[1] = static_cast<float>(src->mElevation);
-    target[2] = static_cast<float>(src->mRadius);
-    mysofa_s2c(target);
-
-    nearest = mysofa_lookup(sofa->lookup, target);
+    std::array target{
+        static_cast<float>(src->mAzimuth),
+        static_cast<float>(src->mElevation),
+        static_cast<float>(src->mRadius)
+    };
+    mysofa_s2c(target.data());
+
+    int nearest{mysofa_lookup(sofa->lookup, target.data())};
     if(nearest < 0)
     {
-        fprintf(stderr, "\nError: Lookup failed in source file '%s'.\n", src->mPath);
+        fprintf(stderr, "\nError: Lookup failed in source file '%s'.\n", src->mPath.data());
         return 0;
     }
 
-    coords = &sofa->hrtf->SourcePosition.values[3 * nearest];
-    if(std::abs(coords[0] - target[0]) > 0.001 || std::abs(coords[1] - target[1]) > 0.001 || std::abs(coords[2] - target[2]) > 0.001)
+    al::span<float,3> coords{&sofa->hrtf->SourcePosition.values[3 * nearest], 3};
+    if(std::abs(coords[0] - target[0]) > 0.001 || std::abs(coords[1] - target[1]) > 0.001
+        || std::abs(coords[2] - target[2]) > 0.001)
     {
-        fprintf(stderr, "\nError: No impulse response at coordinates (%.3fr, %.1fev, %.1faz) in file '%s'.\n", src->mRadius, src->mElevation, src->mAzimuth, src->mPath);
+        fprintf(stderr, "\nError: No impulse response at coordinates (%.3fr, %.1fev, %.1faz) in file '%s'.\n",
+            src->mRadius, src->mElevation, src->mAzimuth, src->mPath.data());
         target[0] = coords[0];
         target[1] = coords[1];
         target[2] = coords[2];
-        mysofa_c2s(target);
-        fprintf(stderr, "       Nearest candidate at (%.3fr, %.1fev, %.1faz).\n", target[2], target[1], target[0]);
+        mysofa_c2s(target.data());
+        fprintf(stderr, "       Nearest candidate at (%.3fr, %.1fev, %.1faz).\n", target[2],
+            target[1], target[0]);
         return 0;
     }
 
@@ -1180,12 +1175,12 @@ static int LoadSource(SourceRefT *src, const uint hrirRate, const uint n, double
     if(src->mFormat != SF_SOFA)
     {
         if(src->mFormat == SF_ASCII)
-            istream.reset(new al::ifstream{src->mPath});
+            istream = std::make_unique<al::ifstream>(src->mPath.data());
         else
-            istream.reset(new al::ifstream{src->mPath, std::ios::binary});
+            istream = std::make_unique<al::ifstream>(src->mPath.data(), std::ios::binary);
         if(!istream->good())
         {
-            fprintf(stderr, "\nError: Could not open source file '%s'.\n", src->mPath);
+            fprintf(stderr, "\nError: Could not open source file '%s'.\n", src->mPath.data());
             return 0;
         }
     }
@@ -1230,14 +1225,14 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
 {
     int hasRate = 0, hasType = 0, hasPoints = 0, hasRadius = 0;
     int hasDistance = 0, hasAzimuths = 0;
-    char ident[MAX_IDENT_LEN+1];
+    std::array<char,MAX_IDENT_LEN+1> ident;
     uint line, col;
     double fpVal;
     uint points;
     int intVal;
-    double distances[MAX_FD_COUNT];
+    std::array<double,MAX_FD_COUNT> distances;
     uint fdCount = 0;
-    uint evCounts[MAX_FD_COUNT];
+    std::array<uint,MAX_FD_COUNT> evCounts;
     auto azCounts = std::vector<std::array<uint,MAX_EV_COUNT>>(MAX_FD_COUNT);
     for(auto &azs : azCounts) azs.fill(0u);
 
@@ -1245,9 +1240,9 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
     while(TrIsIdent(tr))
     {
         TrIndication(tr, &line, &col);
-        if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
+        if(!TrReadIdent(tr, MAX_IDENT_LEN, ident.data()))
             return 0;
-        if(al::strcasecmp(ident, "rate") == 0)
+        if(al::strcasecmp(ident.data(), "rate") == 0)
         {
             if(hasRate)
             {
@@ -1261,9 +1256,9 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             hData->mIrRate = static_cast<uint>(intVal);
             hasRate = 1;
         }
-        else if(al::strcasecmp(ident, "type") == 0)
+        else if(al::strcasecmp(ident.data(), "type") == 0)
         {
-            char type[MAX_IDENT_LEN+1];
+            std::array<char,MAX_IDENT_LEN+1> type;
 
             if(hasType)
             {
@@ -1273,9 +1268,9 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             if(!TrReadOperator(tr, "="))
                 return 0;
 
-            if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
+            if(!TrReadIdent(tr, MAX_IDENT_LEN, type.data()))
                 return 0;
-            hData->mChannelType = MatchChannelType(type);
+            hData->mChannelType = MatchChannelType(type.data());
             if(hData->mChannelType == CT_NONE)
             {
                 TrErrorAt(tr, line, col, "Expected a channel type.\n");
@@ -1288,7 +1283,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             }
             hasType = 1;
         }
-        else if(al::strcasecmp(ident, "points") == 0)
+        else if(al::strcasecmp(ident.data(), "points") == 0)
         {
             if(hasPoints)
             {
@@ -1318,7 +1313,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
                 hData->mIrSize = points;
             hasPoints = 1;
         }
-        else if(al::strcasecmp(ident, "radius") == 0)
+        else if(al::strcasecmp(ident.data(), "radius") == 0)
         {
             if(hasRadius)
             {
@@ -1332,7 +1327,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             hData->mRadius = fpVal;
             hasRadius = 1;
         }
-        else if(al::strcasecmp(ident, "distance") == 0)
+        else if(al::strcasecmp(ident.data(), "distance") == 0)
         {
             uint count = 0;
 
@@ -1371,7 +1366,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
             fdCount = count;
             hasDistance = 1;
         }
-        else if(al::strcasecmp(ident, "azimuths") == 0)
+        else if(al::strcasecmp(ident.data(), "azimuths") == 0)
         {
             uint count = 0;
 
@@ -1451,7 +1446,7 @@ static int ProcessMetrics(TokenReaderT *tr, const uint fftSize, const uint trunc
     if(hData->mChannelType == CT_NONE)
         hData->mChannelType = CT_MONO;
     const auto azs = al::span{azCounts}.first<MAX_FD_COUNT>();
-    if(!PrepareHrirData({distances, fdCount}, evCounts, azs, hData))
+    if(!PrepareHrirData(al::span{distances}.first(fdCount), evCounts, azs, hData))
     {
         fprintf(stderr, "Error:  Out of memory.\n");
         exit(-1);
@@ -1516,15 +1511,15 @@ static ElementTypeT MatchElementType(const char *ident)
 // Parse and validate a source reference from the data set definition.
 static int ReadSourceRef(TokenReaderT *tr, SourceRefT *src)
 {
-    char ident[MAX_IDENT_LEN+1];
+    std::array<char,MAX_IDENT_LEN+1> ident;
     uint line, col;
     double fpVal;
     int intVal;
 
     TrIndication(tr, &line, &col);
-    if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
+    if(!TrReadIdent(tr, MAX_IDENT_LEN, ident.data()))
         return 0;
-    src->mFormat = MatchSourceFormat(ident);
+    src->mFormat = MatchSourceFormat(ident.data());
     if(src->mFormat == SF_NONE)
     {
         TrErrorAt(tr, line, col, "Expected a source format.\n");
@@ -1570,9 +1565,9 @@ static int ReadSourceRef(TokenReaderT *tr, SourceRefT *src)
     else
     {
         TrIndication(tr, &line, &col);
-        if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
+        if(!TrReadIdent(tr, MAX_IDENT_LEN, ident.data()))
             return 0;
-        src->mType = MatchElementType(ident);
+        src->mType = MatchElementType(ident.data());
         if(src->mType == ET_NONE)
         {
             TrErrorAt(tr, line, col, "Expected a source element type.\n");
@@ -1655,7 +1650,7 @@ static int ReadSourceRef(TokenReaderT *tr, SourceRefT *src)
         src->mOffset = 0;
     if(!TrReadOperator(tr, ":"))
         return 0;
-    if(!TrReadString(tr, MAX_PATH_LEN, src->mPath))
+    if(!TrReadString(tr, MAX_PATH_LEN, src->mPath.data()))
         return 0;
     return 1;
 }
@@ -1663,14 +1658,14 @@ static int ReadSourceRef(TokenReaderT *tr, SourceRefT *src)
 // Parse and validate a SOFA source reference from the data set definition.
 static int ReadSofaRef(TokenReaderT *tr, SourceRefT *src)
 {
-    char ident[MAX_IDENT_LEN+1];
+    std::array<char,MAX_IDENT_LEN+1> ident;
     uint line, col;
     int intVal;
 
     TrIndication(tr, &line, &col);
-    if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
+    if(!TrReadIdent(tr, MAX_IDENT_LEN, ident.data()))
         return 0;
-    src->mFormat = MatchSourceFormat(ident);
+    src->mFormat = MatchSourceFormat(ident.data());
     if(src->mFormat != SF_SOFA)
     {
         TrErrorAt(tr, line, col, "Expected the SOFA source format.\n");
@@ -1694,7 +1689,7 @@ static int ReadSofaRef(TokenReaderT *tr, SourceRefT *src)
         src->mOffset = 0;
     if(!TrReadOperator(tr, ":"))
         return 0;
-    if(!TrReadString(tr, MAX_PATH_LEN, src->mPath))
+    if(!TrReadString(tr, MAX_PATH_LEN, src->mPath.data()))
         return 0;
     return 1;
 }
@@ -1747,7 +1742,7 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
     const uint channels{(hData->mChannelType == CT_STEREO) ? 2u : 1u};
     hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize);
     double *hrirs = hData->mHrirsBase.data();
-    auto hrir = std::make_unique<double[]>(hData->mIrSize);
+    auto hrir = std::vector<double>(hData->mIrSize);
     uint line, col, fi, ei, ai;
 
     std::vector<double> onsetSamples(OnsetRateMultiple * hData->mIrPoints);
@@ -1767,57 +1762,50 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
     int count{0};
     while(TrIsOperator(tr, "["))
     {
-        double factor[2]{ 1.0, 1.0 };
+        std::array factor{1.0, 1.0};
 
         TrIndication(tr, &line, &col);
         TrReadOperator(tr, "[");
 
         if(TrIsOperator(tr, "*"))
         {
-            SourceRefT src;
-            struct MYSOFA_EASY *sofa;
-            uint si;
-
             TrReadOperator(tr, "*");
             if(!TrReadOperator(tr, "]") || !TrReadOperator(tr, "="))
                 return 0;
 
             TrIndication(tr, &line, &col);
+            SourceRefT src{};
             if(!ReadSofaRef(tr, &src))
                 return 0;
 
             if(hData->mChannelType == CT_STEREO)
             {
-                char type[MAX_IDENT_LEN+1];
-                ChannelTypeT channelType;
+                std::array<char,MAX_IDENT_LEN+1> type{};
 
-                if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
+                if(!TrReadIdent(tr, MAX_IDENT_LEN, type.data()))
                     return 0;
 
-                channelType = MatchChannelType(type);
-
+                const ChannelTypeT channelType{MatchChannelType(type.data())};
                 switch(channelType)
                 {
-                    case CT_NONE:
-                        TrErrorAt(tr, line, col, "Expected a channel type.\n");
-                        return 0;
-                    case CT_MONO:
-                        src.mChannel = 0;
-                        break;
-                    case CT_STEREO:
-                        src.mChannel = 1;
-                        break;
+                case CT_NONE:
+                    TrErrorAt(tr, line, col, "Expected a channel type.\n");
+                    return 0;
+                case CT_MONO:
+                    src.mChannel = 0;
+                    break;
+                case CT_STEREO:
+                    src.mChannel = 1;
+                    break;
                 }
             }
             else
             {
-                char type[MAX_IDENT_LEN+1];
-                ChannelTypeT channelType;
-
-                if(!TrReadIdent(tr, MAX_IDENT_LEN, type))
+                std::array<char,MAX_IDENT_LEN+1> type{};
+                if(!TrReadIdent(tr, MAX_IDENT_LEN, type.data()))
                     return 0;
 
-                channelType = MatchChannelType(type);
+                ChannelTypeT channelType{MatchChannelType(type.data())};
                 if(channelType != CT_MONO)
                 {
                     TrErrorAt(tr, line, col, "Expected a mono channel type.\n");
@@ -1826,20 +1814,20 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
                 src.mChannel = 0;
             }
 
-            sofa = LoadSofaFile(&src, hData->mIrRate, hData->mIrPoints);
+            MYSOFA_EASY *sofa{LoadSofaFile(&src, hData->mIrRate, hData->mIrPoints)};
             if(!sofa) return 0;
 
-            for(si = 0;si < sofa->hrtf->M;si++)
+            for(uint si{0};si < sofa->hrtf->M;++si)
             {
                 printf("\rLoading sources... %d of %d", si+1, sofa->hrtf->M);
                 fflush(stdout);
 
-                float aer[3] = {
+                std::array aer{
                     sofa->hrtf->SourcePosition.values[3*si],
                     sofa->hrtf->SourcePosition.values[3*si + 1],
                     sofa->hrtf->SourcePosition.values[3*si + 2]
                 };
-                mysofa_c2s(aer);
+                mysofa_c2s(aer.data());
 
                 if(std::fabs(aer[1]) >= 89.999f)
                     aer[0] = 0.0f;
@@ -1875,24 +1863,25 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
                     return 0;
                 }
 
-                ExtractSofaHrir(sofa, si, 0, src.mOffset, hData->mIrPoints, hrir.get());
+                ExtractSofaHrir(sofa, si, 0, src.mOffset, hData->mIrPoints, hrir.data());
                 azd->mIrs[0] = &hrirs[hData->mIrSize * azd->mIndex];
                 azd->mDelays[0] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
-                    hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[0]);
+                    hData->mIrPoints, hrir.data(), 1.0, azd->mDelays[0]);
                 if(resampler)
-                    resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
-                AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[0]);
+                    resampler->process(hData->mIrPoints, hrir.data(), hData->mIrSize, hrir.data());
+                AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.data(), 1.0, azd->mIrs[0]);
 
                 if(src.mChannel == 1)
                 {
-                    ExtractSofaHrir(sofa, si, 1, src.mOffset, hData->mIrPoints, hrir.get());
+                    ExtractSofaHrir(sofa, si, 1, src.mOffset, hData->mIrPoints, hrir.data());
                     azd->mIrs[1] = &hrirs[hData->mIrSize * (hData->mIrCount + azd->mIndex)];
                     azd->mDelays[1] = AverageHrirOnset(onsetResampler, onsetSamples,
-                        hData->mIrRate, hData->mIrPoints, hrir.get(), 1.0, azd->mDelays[1]);
+                        hData->mIrRate, hData->mIrPoints, hrir.data(), 1.0, azd->mDelays[1]);
                     if(resampler)
-                        resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize,
-                            hrir.get());
-                    AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0, azd->mIrs[1]);
+                        resampler->process(hData->mIrPoints, hrir.data(), hData->mIrSize,
+                            hrir.data());
+                    AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.data(), 1.0,
+                        azd->mIrs[1]);
                 }
 
                 // TODO: Since some SOFA files contain minimum phase HRIRs,
@@ -1917,10 +1906,9 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
         if(!TrReadOperator(tr, "="))
             return 0;
 
-        for(;;)
+        while(true)
         {
-            SourceRefT src;
-
+            SourceRefT src{};
             if(!ReadSourceRef(tr, &src))
                 return 0;
 
@@ -1931,17 +1919,16 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
             printf("\rLoading sources... %d file%s", count, (count==1)?"":"s");
             fflush(stdout);
 
-            if(!LoadSource(&src, hData->mIrRate, hData->mIrPoints, hrir.get()))
+            if(!LoadSource(&src, hData->mIrRate, hData->mIrPoints, hrir.data()))
                 return 0;
 
             uint ti{0};
             if(hData->mChannelType == CT_STEREO)
             {
-                char ident[MAX_IDENT_LEN+1];
-
-                if(!TrReadIdent(tr, MAX_IDENT_LEN, ident))
+                std::array<char,MAX_IDENT_LEN+1> ident{};
+                if(!TrReadIdent(tr, MAX_IDENT_LEN, ident.data()))
                     return 0;
-                ti = static_cast<uint>(MatchTargetEar(ident));
+                ti = static_cast<uint>(MatchTargetEar(ident.data()));
                 if(static_cast<int>(ti) < 0)
                 {
                     TrErrorAt(tr, line, col, "Expected a target ear.\n");
@@ -1950,10 +1937,10 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
             }
             azd->mIrs[ti] = &hrirs[hData->mIrSize * (ti * hData->mIrCount + azd->mIndex)];
             azd->mDelays[ti] = AverageHrirOnset(onsetResampler, onsetSamples, hData->mIrRate,
-                hData->mIrPoints, hrir.get(), 1.0 / factor[ti], azd->mDelays[ti]);
+                hData->mIrPoints, hrir.data(), 1.0 / factor[ti], azd->mDelays[ti]);
             if(resampler)
-                resampler->process(hData->mIrPoints, hrir.get(), hData->mIrSize, hrir.get());
-            AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.get(), 1.0 / factor[ti],
+                resampler->process(hData->mIrPoints, hrir.data(), hData->mIrSize, hrir.data());
+            AverageHrirMagnitude(irPoints, hData->mFftSize, hrir.data(), 1.0 / factor[ti],
                 azd->mIrs[ti]);
             factor[ti] += 1.0;
             if(!TrIsOperator(tr, "+"))
@@ -1975,7 +1962,7 @@ static int ProcessSources(TokenReaderT *tr, HrirDataT *hData, const uint outRate
         }
     }
     printf("\n");
-    hrir = nullptr;
+    hrir.clear();
     if(resampler)
     {
         hData->mIrRate = outRate;
diff --git a/utils/makemhr/loadsofa.cpp b/utils/makemhr/loadsofa.cpp
index 9bcfc38d..4b2ba2f4 100644
--- a/utils/makemhr/loadsofa.cpp
+++ b/utils/makemhr/loadsofa.cpp
@@ -65,8 +65,8 @@ static bool PrepareLayout(const uint m, const float *xyzs, HrirDataT *hData)
         return false;
     }
 
-    double distances[MAX_FD_COUNT]{};
-    uint evCounts[MAX_FD_COUNT]{};
+    std::array<double,MAX_FD_COUNT> distances{};
+    std::array<uint,MAX_FD_COUNT> evCounts{};
     auto azCounts = std::vector<std::array<uint,MAX_EV_COUNT>>(MAX_FD_COUNT);
     for(auto &azs : azCounts) azs.fill(0u);
 
@@ -88,7 +88,7 @@ static bool PrepareLayout(const uint m, const float *xyzs, HrirDataT *hData)
     }
     fprintf(stdout, "Using %u of %u IRs.\n", ir_total, m);
     const auto azs = al::span{azCounts}.first<MAX_FD_COUNT>();
-    return PrepareHrirData({distances, fi}, evCounts, azs, hData);
+    return PrepareHrirData(al::span{distances}.first(fi), evCounts, azs, hData);
 }
 
 
@@ -264,24 +264,24 @@ static bool LoadResponses(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData, const DelayTy
         hData->mHrirsBase.resize(channels * hData->mIrCount * hData->mIrSize, 0.0);
         double *hrirs = hData->mHrirsBase.data();
 
-        std::unique_ptr<double[]> restmp;
+        std::vector<double> restmp;
         std::optional<PPhaseResampler> resampler;
         if(outRate && outRate != hData->mIrRate)
         {
             resampler.emplace().init(hData->mIrRate, outRate);
-            restmp = std::make_unique<double[]>(sofaHrtf->N);
+            restmp.resize(sofaHrtf->N);
         }
 
         for(uint si{0u};si < sofaHrtf->M;++si)
         {
             loaded_count.fetch_add(1u);
 
-            float aer[3]{
+            std::array aer{
                 sofaHrtf->SourcePosition.values[3*si],
                 sofaHrtf->SourcePosition.values[3*si + 1],
                 sofaHrtf->SourcePosition.values[3*si + 2]
             };
-            mysofa_c2s(aer);
+            mysofa_c2s(aer.data());
 
             if(std::abs(aer[1]) >= 89.999f)
                 aer[0] = 0.0f;
@@ -324,8 +324,8 @@ static bool LoadResponses(MYSOFA_HRTF *sofaHrtf, HrirDataT *hData, const DelayTy
                 else
                 {
                     std::copy_n(&sofaHrtf->DataIR.values[(si*sofaHrtf->R + ti)*sofaHrtf->N],
-                        sofaHrtf->N, restmp.get());
-                    resampler->process(sofaHrtf->N, restmp.get(), hData->mIrSize, azd->mIrs[ti]);
+                        sofaHrtf->N, restmp.data());
+                    resampler->process(sofaHrtf->N, restmp.data(), hData->mIrSize, azd->mIrs[ti]);
                 }
             }
 
@@ -382,7 +382,7 @@ struct MagCalculator {
     {
         auto htemp = std::vector<complex_d>(mFftSize);
 
-        while(1)
+        while(true)
         {
             /* Load the current index to process. */
             size_t idx{mCurrent.load()};
diff --git a/utils/makemhr/makemhr.cpp b/utils/makemhr/makemhr.cpp
index 8291ac0f..3c0da19f 100644
--- a/utils/makemhr/makemhr.cpp
+++ b/utils/makemhr/makemhr.cpp
@@ -324,13 +324,11 @@ static int WriteAscii(const char *out, FILE *fp, const char *filename)
 // loading it from a 32-bit unsigned integer.
 static int WriteBin4(const uint bytes, const uint32_t in, FILE *fp, const char *filename)
 {
-    uint8_t out[4];
-    uint i;
-
-    for(i = 0;i < bytes;i++)
+    std::array<uint8_t,4> out{};
+    for(uint i{0};i < bytes;i++)
         out[i] = (in>>(i*8)) & 0x000000FF;
 
-    if(fwrite(out, 1, bytes, fp) != bytes)
+    if(fwrite(out.data(), 1, bytes, fp) != bytes)
     {
         fprintf(stderr, "\nError: Bad write to file '%s'.\n", filename);
         return 0;
@@ -387,11 +385,11 @@ static int StoreMhr(const HrirDataT *hData, const char *filename)
             for(ai = 0;ai < hData->mFds[fi].mEvs[ei].mAzs.size();ai++)
             {
                 HrirAzT *azd = &hData->mFds[fi].mEvs[ei].mAzs[ai];
-                double out[2 * MAX_TRUNCSIZE];
+                std::array<double,2*MAX_TRUNCSIZE> out{};
 
-                TpdfDither(out, azd->mIrs[0], scale, n, channels, &dither_seed);
+                TpdfDither(out.data(), azd->mIrs[0], scale, n, channels, &dither_seed);
                 if(hData->mChannelType == CT_STEREO)
-                    TpdfDither(out+1, azd->mIrs[1], scale, n, channels, &dither_seed);
+                    TpdfDither(out.data()+1, azd->mIrs[1], scale, n, channels, &dither_seed);
                 for(i = 0;i < (channels * n);i++)
                 {
                     const auto v = static_cast<int>(Clamp(out[i], -scale-1.0, scale));
@@ -732,12 +730,12 @@ static void SynthesizeOnsets(HrirDataT *hData)
                 double az{field.mEvs[ei].mAzs[ai].mAzimuth};
                 CalcAzIndices(field, upperElevReal, az, &a0, &a1, &af0);
                 CalcAzIndices(field, lowerElevFake, az, &a2, &a3, &af1);
-                double blend[4]{
+                std::array<double,4> blend{{
                     (1.0-ef) * (1.0-af0),
                     (1.0-ef) * (    af0),
                     (    ef) * (1.0-af1),
                     (    ef) * (    af1)
-                };
+                }};
 
                 for(uint ti{0u};ti < channels;ti++)
                 {
@@ -794,7 +792,7 @@ static void SynthesizeHrirs(HrirDataT *hData)
         {
             const double of{static_cast<double>(ei) / field.mEvStart};
             const double b{(1.0 - of) * beta};
-            double lp[4]{};
+            std::array<double,4> lp{};
 
             /* Calculate a low-pass filter to simulate body occlusion. */
             lp[0] = Lerp(1.0, lp[0], b);
@@ -839,7 +837,7 @@ static void SynthesizeHrirs(HrirDataT *hData)
             }
         }
         const double b{beta};
-        double lp[4]{};
+        std::array<double,4> lp{};
         lp[0] = Lerp(1.0, lp[0], b);
         lp[1] = Lerp(lp[0], lp[1], b);
         lp[2] = Lerp(lp[1], lp[2], b);
@@ -885,7 +883,7 @@ struct HrirReconstructor {
         auto mags = std::vector<double>(mFftSize);
         size_t m{(mFftSize/2) + 1};
 
-        while(1)
+        while(true)
         {
             /* Load the current index to process. */
             size_t idx{mCurrent.load()};
@@ -988,7 +986,7 @@ static void NormalizeHrirs(HrirDataT *hData)
         return LevelPair{std::max(current.amp, levels.amp), std::max(current.rms, levels.rms)};
     };
     auto measure_azi = [channels,mesasure_channel](const LevelPair levels, const HrirAzT &azi)
-    { return std::accumulate(azi.mIrs, azi.mIrs+channels, levels, mesasure_channel); };
+    { return std::accumulate(azi.mIrs.begin(), azi.mIrs.begin()+channels, levels, mesasure_channel); };
     auto measure_elev = [measure_azi](const LevelPair levels, const HrirEvT &elev)
     { return std::accumulate(elev.mAzs.cbegin(), elev.mAzs.cend(), levels, measure_azi); };
     auto measure_field = [measure_elev](const LevelPair levels, const HrirFdT &field)
@@ -1015,7 +1013,7 @@ static void NormalizeHrirs(HrirDataT *hData)
     auto proc_channel = [irSize,factor](double *ir)
     { std::transform(ir, ir+irSize, ir, [factor](double s){ return s * factor; }); };
     auto proc_azi = [channels,proc_channel](HrirAzT &azi)
-    { std::for_each(azi.mIrs, azi.mIrs+channels, proc_channel); };
+    { std::for_each(azi.mIrs.begin(), azi.mIrs.begin()+channels, proc_channel); };
     auto proc_elev = [proc_azi](HrirEvT &elev)
     { std::for_each(elev.mAzs.begin(), elev.mAzs.end(), proc_azi); };
     auto proc1_field = [proc_elev](HrirFdT &field)
@@ -1196,10 +1194,10 @@ static int ProcessDefinition(const char *inName, const uint outRate, const Chann
             return 0;
         }
 
-        char startbytes[4]{};
-        input->read(startbytes, sizeof(startbytes));
+        std::array<char,4> startbytes{};
+        input->read(startbytes.data(), startbytes.size());
         std::streamsize startbytecount{input->gcount()};
-        if(startbytecount != sizeof(startbytes) || !input->good())
+        if(startbytecount != startbytes.size() || !input->good())
         {
             fprintf(stderr, "Error: Could not read input file '%s'\n", inName);
             return 0;
@@ -1216,7 +1214,8 @@ static int ProcessDefinition(const char *inName, const uint outRate, const Chann
         else
         {
             fprintf(stdout, "Reading HRIR definition from %s...\n", inName);
-            if(!LoadDefInput(*input, startbytes, startbytecount, inName, fftSize, truncSize, outRate, chanMode, &hData))
+            if(!LoadDefInput(*input, startbytes.data(), startbytecount, inName, fftSize, truncSize,
+                outRate, chanMode, &hData))
                 return 0;
         }
     }
diff --git a/utils/makemhr/makemhr.h b/utils/makemhr/makemhr.h
index aa18134d..3a105fc2 100644
--- a/utils/makemhr/makemhr.h
+++ b/utils/makemhr/makemhr.h
@@ -68,8 +68,8 @@ enum ChannelTypeT {
 struct HrirAzT {
     double mAzimuth{0.0};
     uint mIndex{0u};
-    double mDelays[2]{0.0, 0.0};
-    double *mIrs[2]{nullptr, nullptr};
+    std::array<double,2> mDelays{};
+    std::array<double*,2> mIrs{};
 };
 
 struct HrirEvT {
diff --git a/utils/sofa-info.cpp b/utils/sofa-info.cpp
index 6dffef44..7775b8e3 100644
--- a/utils/sofa-info.cpp
+++ b/utils/sofa-info.cpp
@@ -21,8 +21,7 @@
  * Or visit:  http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
  */
 
-#include <stdio.h>
-
+#include <cstdio>
 #include <memory>
 #include <vector>
 
diff --git a/utils/sofa-support.cpp b/utils/sofa-support.cpp
index e37789d5..ceb3067a 100644
--- a/utils/sofa-support.cpp
+++ b/utils/sofa-support.cpp
@@ -24,11 +24,11 @@
 
 #include "sofa-support.h"
 
-#include <stdio.h>
 
 #include <algorithm>
 #include <array>
 #include <cmath>
+#include <cstdio>
 #include <utility>
 #include <vector>
 
@@ -47,7 +47,7 @@ using double3 = std::array<double,3>;
  * equality of unique elements.
  */
 std::vector<double> GetUniquelySortedElems(const std::vector<double3> &aers, const uint axis,
-    const double *const (&filters)[3], const double (&epsilons)[3])
+    const std::array<const double*,3> filters, const std::array<double,3> epsilons)
 {
     std::vector<double> elems;
     for(const double3 &aer : aers)
@@ -183,8 +183,8 @@ std::vector<SofaField> GetCompatibleLayout(const size_t m, const float *xyzs)
     auto aers = std::vector<double3>(m, double3{});
     for(size_t i{0u};i < m;++i)
     {
-        float vals[3]{xyzs[i*3], xyzs[i*3 + 1], xyzs[i*3 + 2]};
-        mysofa_c2s(&vals[0]);
+        std::array vals{xyzs[i*3], xyzs[i*3 + 1], xyzs[i*3 + 2]};
+        mysofa_c2s(vals.data());
         aers[i] = {vals[0], vals[1], vals[2]};
     }
 
diff --git a/utils/uhjdecoder.cpp b/utils/uhjdecoder.cpp
index c7efa376..feca0a35 100644
--- a/utils/uhjdecoder.cpp
+++ b/utils/uhjdecoder.cpp
@@ -66,22 +66,22 @@ using complex_d = std::complex<double>;
 using byte4 = std::array<std::byte,4>;
 
 
-constexpr ubyte SUBTYPE_BFORMAT_FLOAT[]{
+constexpr std::array<ubyte,16> SUBTYPE_BFORMAT_FLOAT{
     0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
     0xca, 0x00, 0x00, 0x00
 };
 
 void fwrite16le(ushort val, FILE *f)
 {
-    ubyte data[2]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff) };
-    fwrite(data, 1, 2, f);
+    std::array data{static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff)};
+    fwrite(data.data(), 1, data.size(), f);
 }
 
 void fwrite32le(uint val, FILE *f)
 {
-    ubyte data[4]{ static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff),
-        static_cast<ubyte>((val>>16)&0xff), static_cast<ubyte>((val>>24)&0xff) };
-    fwrite(data, 1, 4, f);
+    std::array data{static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff),
+        static_cast<ubyte>((val>>16)&0xff), static_cast<ubyte>((val>>24)&0xff)};
+    fwrite(data.data(), 1, data.size(), f);
 }
 
 template<al::endian = al::endian::native>
@@ -389,7 +389,7 @@ int main(int argc, char **argv)
             fprintf(stderr, "Failed to open %s\n", argv[fidx]);
             continue;
         }
-        if(sf_command(infile.get(), SFC_WAVEX_GET_AMBISONIC, NULL, 0) == SF_AMBISONIC_B_FORMAT)
+        if(sf_command(infile.get(), SFC_WAVEX_GET_AMBISONIC, nullptr, 0) == SF_AMBISONIC_B_FORMAT)
         {
             fprintf(stderr, "%s is already B-Format\n", argv[fidx]);
             continue;
@@ -438,7 +438,7 @@ int main(int argc, char **argv)
         // 32-bit val, frequency
         fwrite32le(static_cast<uint>(ininfo.samplerate), outfile.get());
         // 32-bit val, bytes per second
-        fwrite32le(static_cast<uint>(ininfo.samplerate)*sizeof(float)*outchans, outfile.get());
+        fwrite32le(static_cast<uint>(ininfo.samplerate)*outchans*sizeof(float), outfile.get());
         // 16-bit val, frame size
         fwrite16le(static_cast<ushort>(sizeof(float)*outchans), outfile.get());
         // 16-bit val, bits per sample
@@ -450,7 +450,7 @@ int main(int argc, char **argv)
         // 32-bit val, channel mask
         fwrite32le(0, outfile.get());
         // 16 byte GUID, sub-type format
-        fwrite(SUBTYPE_BFORMAT_FLOAT, 1, 16, outfile.get());
+        fwrite(SUBTYPE_BFORMAT_FLOAT.data(), 1, SUBTYPE_BFORMAT_FLOAT.size(), outfile.get());
 
         fputs("data", outfile.get());
         fwrite32le(0xFFFFFFFF, outfile.get()); // 'data' header len; filled in at close
@@ -463,9 +463,9 @@ int main(int argc, char **argv)
         auto DataStart = ftell(outfile.get());
 
         auto decoder = std::make_unique<UhjDecoder>();
-        auto inmem = std::make_unique<float[]>(BufferLineSize*static_cast<uint>(ininfo.channels));
+        auto inmem = std::vector<float>(BufferLineSize*static_cast<uint>(ininfo.channels));
         auto decmem = al::vector<std::array<float,BufferLineSize>, 16>(outchans);
-        auto outmem = std::make_unique<byte4[]>(BufferLineSize*outchans);
+        auto outmem = std::vector<byte4>(BufferLineSize*outchans);
 
         /* A number of initial samples need to be skipped to cut the lead-in
          * from the all-pass filter delay. The same number of samples need to
@@ -476,21 +476,21 @@ int main(int argc, char **argv)
         sf_count_t LeadOut{UhjDecoder::sFilterDelay};
         while(LeadOut > 0)
         {
-            sf_count_t sgot{sf_readf_float(infile.get(), inmem.get(), BufferLineSize)};
+            sf_count_t sgot{sf_readf_float(infile.get(), inmem.data(), BufferLineSize)};
             sgot = std::max<sf_count_t>(sgot, 0);
             if(sgot < BufferLineSize)
             {
                 const sf_count_t remaining{std::min(BufferLineSize - sgot, LeadOut)};
-                std::fill_n(inmem.get() + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
+                std::fill_n(inmem.data() + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
                 sgot += remaining;
                 LeadOut -= remaining;
             }
 
             auto got = static_cast<std::size_t>(sgot);
             if(ininfo.channels > 2 || use_general)
-                decoder->decode(inmem.get(), static_cast<uint>(ininfo.channels), decmem, got);
+                decoder->decode(inmem.data(), static_cast<uint>(ininfo.channels), decmem, got);
             else
-                decoder->decode2(inmem.get(), decmem, got);
+                decoder->decode2(inmem.data(), decmem, got);
             if(LeadIn >= got)
             {
                 LeadIn -= got;
@@ -507,7 +507,7 @@ int main(int argc, char **argv)
             }
             LeadIn = 0;
 
-            std::size_t wrote{fwrite(outmem.get(), sizeof(byte4)*outchans, got, outfile.get())};
+            std::size_t wrote{fwrite(outmem.data(), sizeof(byte4)*outchans, got, outfile.get())};
             if(wrote < got)
             {
                 fprintf(stderr, "Error writing wave data: %s (%d)\n", strerror(errno), errno);
diff --git a/utils/uhjencoder.cpp b/utils/uhjencoder.cpp
index 154a1155..8673dd59 100644
--- a/utils/uhjencoder.cpp
+++ b/utils/uhjencoder.cpp
@@ -26,9 +26,9 @@
 
 #include <array>
 #include <cinttypes>
+#include <cstddef>
 #include <cstring>
 #include <memory>
-#include <stddef.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ -179,50 +179,55 @@ struct SpeakerPos {
 };
 
 /* Azimuth is counter-clockwise. */
-constexpr SpeakerPos StereoMap[2]{
-    { SF_CHANNEL_MAP_LEFT,   30.0f, 0.0f },
-    { SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f },
-}, QuadMap[4]{
-    { SF_CHANNEL_MAP_LEFT,         45.0f, 0.0f },
-    { SF_CHANNEL_MAP_RIGHT,       -45.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_LEFT,   135.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_RIGHT, -135.0f, 0.0f },
-}, X51Map[6]{
-    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
-    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
-    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
-    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
-    { SF_CHANNEL_MAP_SIDE_LEFT,   110.0f, 0.0f },
-    { SF_CHANNEL_MAP_SIDE_RIGHT, -110.0f, 0.0f },
-}, X51RearMap[6]{
-    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
-    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
-    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
-    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_LEFT,   110.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_RIGHT, -110.0f, 0.0f },
-}, X71Map[8]{
-    { SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f },
-    { SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f },
-    { SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f },
-    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_LEFT,   150.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f, 0.0f },
-    { SF_CHANNEL_MAP_SIDE_LEFT,    90.0f, 0.0f },
-    { SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f, 0.0f },
-}, X714Map[12]{
-    { SF_CHANNEL_MAP_LEFT,         30.0f,  0.0f },
-    { SF_CHANNEL_MAP_RIGHT,       -30.0f,  0.0f },
-    { SF_CHANNEL_MAP_CENTER,        0.0f,  0.0f },
-    { SF_CHANNEL_MAP_LFE, 0.0f, 0.0f },
-    { SF_CHANNEL_MAP_REAR_LEFT,   150.0f,  0.0f },
-    { SF_CHANNEL_MAP_REAR_RIGHT, -150.0f,  0.0f },
-    { SF_CHANNEL_MAP_SIDE_LEFT,    90.0f,  0.0f },
-    { SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f,  0.0f },
-    { SF_CHANNEL_MAP_TOP_FRONT_LEFT,    45.0f, 35.0f },
-    { SF_CHANNEL_MAP_TOP_FRONT_RIGHT,  -45.0f, 35.0f },
-    { SF_CHANNEL_MAP_TOP_REAR_LEFT,    135.0f, 35.0f },
-    { SF_CHANNEL_MAP_TOP_REAR_RIGHT,  -135.0f, 35.0f },
+constexpr std::array StereoMap{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,   30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT, -30.0f, 0.0f},
+};
+constexpr std::array QuadMap{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,         45.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT,       -45.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_LEFT,   135.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_RIGHT, -135.0f, 0.0f},
+};
+constexpr std::array X51Map{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_LFE, 0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_LEFT,   110.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_RIGHT, -110.0f, 0.0f},
+};
+constexpr std::array X51RearMap{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_LFE, 0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_LEFT,   110.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_RIGHT, -110.0f, 0.0f},
+};
+constexpr std::array X71Map{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,         30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT,       -30.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_CENTER,        0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_LFE, 0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_LEFT,   150.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_RIGHT, -150.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_LEFT,    90.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f, 0.0f},
+};
+constexpr std::array X714Map{
+    SpeakerPos{SF_CHANNEL_MAP_LEFT,         30.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_RIGHT,       -30.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_CENTER,        0.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_LFE, 0.0f, 0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_LEFT,   150.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_REAR_RIGHT, -150.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_LEFT,    90.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_SIDE_RIGHT,  -90.0f,  0.0f},
+    SpeakerPos{SF_CHANNEL_MAP_TOP_FRONT_LEFT,    45.0f, 35.0f},
+    SpeakerPos{SF_CHANNEL_MAP_TOP_FRONT_RIGHT,  -45.0f, 35.0f},
+    SpeakerPos{SF_CHANNEL_MAP_TOP_REAR_LEFT,    135.0f, 35.0f},
+    SpeakerPos{SF_CHANNEL_MAP_TOP_REAR_RIGHT,  -135.0f, 35.0f},
 };
 
 constexpr auto GenCoeffs(double x /*+front*/, double y /*+left*/, double z /*+up*/) noexcept