utils/uhjdecoder.cpp

   1 /*
   2  * 2-channel UHJ Decoder
   3  *
   4  * Copyright (c) Chris Robinson <chris.kcat@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "config.h"
  26
  27 #include <algorithm>
  28 #include <array>
  29 #include <cassert>
  30 #include <cerrno>
  31 #include <complex>
  32 #include <cstddef>
  33 #include <cstdio>
  34 #include <cstring>
  35 #include <memory>
  36 #include <string>
  37 #include <string_view>
  38 #include <system_error>
  39 #include <utility>
  40 #include <vector>
  41
  42 #include "albit.h"
  43 #include "almalloc.h"
  44 #include "alnumbers.h"
  45 #include "alspan.h"
  46 #include "alstring.h"
  47 #include "vector.h"
  48 #include "opthelpers.h"
  49 #include "phase_shifter.h"
  50
  51 #include "sndfile.h"
  52
  53 #include "win_main_utf8.h"
  54
  55
  56 namespace {
  57
  58 struct FileDeleter {
  59     void operator()(gsl::owner<FILE*> file) { fclose(file); }
  60 };
  61 using FilePtr = std::unique_ptr<FILE,FileDeleter>;
  62
  63 struct SndFileDeleter {
  64     void operator()(SNDFILE *sndfile) { sf_close(sndfile); }
  65 };
  66 using SndFilePtr = std::unique_ptr<SNDFILE,SndFileDeleter>;
  67
  68
  69 using ubyte = unsigned char;
  70 using ushort = unsigned short;
  71 using uint = unsigned int;
  72 using complex_d = std::complex<double>;
  73
  74 using byte4 = std::array<std::byte,4>;
  75
  76
  77 constexpr std::array<ubyte,16> SUBTYPE_BFORMAT_FLOAT{
  78     0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
  79     0xca, 0x00, 0x00, 0x00
  80 };
  81
  82 void fwrite16le(ushort val, FILE *f)
  83 {
  84     std::array data{static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff)};
  85     fwrite(data.data(), 1, data.size(), f);
  86 }
  87
  88 void fwrite32le(uint val, FILE *f)
  89 {
  90     std::array data{static_cast<ubyte>(val&0xff), static_cast<ubyte>((val>>8)&0xff),
  91         static_cast<ubyte>((val>>16)&0xff), static_cast<ubyte>((val>>24)&0xff)};
  92     fwrite(data.data(), 1, data.size(), f);
  93 }
  94
  95 byte4 f32AsLEBytes(const float &value)
  96 {
  97     byte4 ret{};
  98     std::memcpy(ret.data(), &value, 4);
  99     if constexpr(al::endian::native == al::endian::big)
 100     {
 101         std::swap(ret[0], ret[3]);
 102         std::swap(ret[1], ret[2]);
 103     }
 104     return ret;
 105 }
 106
 107
 108 constexpr uint BufferLineSize{1024};
 109
 110 using FloatBufferLine = std::array<float,BufferLineSize>;
 111 using FloatBufferSpan = al::span<float,BufferLineSize>;
 112
 113
 114 struct UhjDecoder {
 115     constexpr static std::size_t sFilterDelay{1024};
 116
 117     alignas(16) std::array<float,BufferLineSize+sFilterDelay> mS{};
 118     alignas(16) std::array<float,BufferLineSize+sFilterDelay> mD{};
 119     alignas(16) std::array<float,BufferLineSize+sFilterDelay> mT{};
 120     alignas(16) std::array<float,BufferLineSize+sFilterDelay> mQ{};
 121
 122     /* History for the FIR filter. */
 123     alignas(16) std::array<float,sFilterDelay-1> mDTHistory{};
 124     alignas(16) std::array<float,sFilterDelay-1> mSHistory{};
 125
 126     alignas(16) std::array<float,BufferLineSize + sFilterDelay*2> mTemp{};
 127
 128     void decode(const al::span<const float> InSamples, const std::size_t InChannels,
 129         const al::span<FloatBufferLine> OutSamples, const std::size_t SamplesToDo);
 130     void decode2(const al::span<const float> InSamples, const al::span<FloatBufferLine> OutSamples,
 131         const std::size_t SamplesToDo);
 132 };
 133
 134 const PhaseShifterT<UhjDecoder::sFilterDelay*2> PShift{};
 135
 136
 137 /* Decoding UHJ is done as:
 138  *
 139  * S = Left + Right
 140  * D = Left - Right
 141  *
 142  * W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T)
 143  * X = 0.418496*S - j(0.828331*D + 0.767820*T)
 144  * Y = 0.795968*D - 0.676392*T + j(0.186633*S)
 145  * Z = 1.023332*Q
 146  *
 147  * where j is a +90 degree phase shift. 3-channel UHJ excludes Q, while 2-
 148  * channel excludes Q and T. The B-Format signal reconstructed from 2-channel
 149  * UHJ should not be run through a normal B-Format decoder, as it needs
 150  * different shelf filters.
 151  *
 152  * NOTE: Some sources specify
 153  *
 154  * S = (Left + Right)/2
 155  * D = (Left - Right)/2
 156  *
 157  * However, this is incorrect. It's halving Left and Right even though they
 158  * were already halved during encoding, causing S and D to be half what they
 159  * initially were at the encoding stage. This division is not present in
 160  * Gerzon's original paper for deriving Sigma (S) or Delta (D) from the L and R
 161  * signals. As proof, taking Y for example:
 162  *
 163  * Y = 0.795968*D - 0.676392*T + j(0.186633*S)
 164  *
 165  * * Plug in the encoding parameters, using ? as a placeholder for whether S
 166  *   and D should receive an extra 0.5 factor
 167  * Y = 0.795968*(j(-0.3420201*W + 0.5098604*X) + 0.6554516*Y)*? -
 168  *     0.676392*(j(-0.1432*W + 0.6512*X) - 0.7071068*Y) +
 169  *     0.186633*j(0.9396926*W + 0.1855740*X)*?
 170  *
 171  * * Move common factors in
 172  * Y = (j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X) + 0.6554516*0.795968*?*Y) -
 173  *     (j(-0.1432*0.676392*W + 0.6512*0.676392*X) - 0.7071068*0.676392*Y) +
 174  *     j(0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X)
 175  *
 176  * * Clean up extraneous groupings
 177  * Y = j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X) + 0.6554516*0.795968*?*Y -
 178  *     j(-0.1432*0.676392*W + 0.6512*0.676392*X) + 0.7071068*0.676392*Y +
 179  *     j*(0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X)
 180  *
 181  * * Move phase shifts together and combine them
 182  * Y = j(-0.3420201*0.795968*?*W + 0.5098604*0.795968*?*X - -0.1432*0.676392*W -
 183  *        0.6512*0.676392*X + 0.9396926*0.186633*?*W + 0.1855740*0.186633*?*X) +
 184  *     0.6554516*0.795968*?*Y + 0.7071068*0.676392*Y
 185  *
 186  * * Reorder terms
 187  * Y = j(-0.3420201*0.795968*?*W +  0.1432*0.676392*W + 0.9396926*0.186633*?*W +
 188  *        0.5098604*0.795968*?*X + -0.6512*0.676392*X + 0.1855740*0.186633*?*X) +
 189  *     0.7071068*0.676392*Y + 0.6554516*0.795968*?*Y
 190  *
 191  * * Move common factors out
 192  * Y = j((-0.3420201*0.795968*? +  0.1432*0.676392 + 0.9396926*0.186633*?)*W +
 193  *       ( 0.5098604*0.795968*? + -0.6512*0.676392 + 0.1855740*0.186633*?)*X) +
 194  *     (0.7071068*0.676392 + 0.6554516*0.795968*?)*Y
 195  *
 196  * * Result w/ 0.5 factor:
 197  * -0.3420201*0.795968*0.5 +  0.1432*0.676392 + 0.9396926*0.186633*0.5 =  0.04843*W
 198  *  0.5098604*0.795968*0.5 + -0.6512*0.676392 + 0.1855740*0.186633*0.5 = -0.22023*X
 199  *  0.7071068*0.676392                        + 0.6554516*0.795968*0.5 =  0.73914*Y
 200  * -> Y = j(0.04843*W + -0.22023*X) + 0.73914*Y
 201  *
 202  * * Result w/o 0.5 factor:
 203  * -0.3420201*0.795968 +  0.1432*0.676392 + 0.9396926*0.186633 = 0.00000*W
 204  *  0.5098604*0.795968 + -0.6512*0.676392 + 0.1855740*0.186633 = 0.00000*X
 205  *  0.7071068*0.676392                    + 0.6554516*0.795968 = 1.00000*Y
 206  * -> Y = j(0.00000*W + 0.00000*X) + 1.00000*Y
 207  *
 208  * Not halving produces a result matching the original input.
 209  */
 210 void UhjDecoder::decode(const al::span<const float> InSamples, const std::size_t InChannels,
 211     const al::span<FloatBufferLine> OutSamples, const std::size_t SamplesToDo)
 212 {
 213     ASSUME(SamplesToDo > 0);
 214
 215     auto woutput = al::span{OutSamples[0]};
 216     auto xoutput = al::span{OutSamples[1]};
 217     auto youtput = al::span{OutSamples[2]};
 218
 219     /* Add a delay to the input channels, to align it with the all-passed
 220      * signal.
 221      */
 222
 223     /* S = Left + Right */
 224     for(std::size_t i{0};i < SamplesToDo;++i)
 225         mS[sFilterDelay+i] = InSamples[i*InChannels + 0] + InSamples[i*InChannels + 1];
 226
 227     /* D = Left - Right */
 228     for(std::size_t i{0};i < SamplesToDo;++i)
 229         mD[sFilterDelay+i] = InSamples[i*InChannels + 0] - InSamples[i*InChannels + 1];
 230
 231     if(InChannels > 2)
 232     {
 233         /* T */
 234         for(std::size_t i{0};i < SamplesToDo;++i)
 235             mT[sFilterDelay+i] = InSamples[i*InChannels + 2];
 236     }
 237     if(InChannels > 3)
 238     {
 239         /* Q */
 240         for(std::size_t i{0};i < SamplesToDo;++i)
 241             mQ[sFilterDelay+i] = InSamples[i*InChannels + 3];
 242     }
 243
 244     /* Precompute j(0.828331*D + 0.767820*T) and store in xoutput. */
 245     auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
 246     std::transform(mD.cbegin(), mD.cbegin()+SamplesToDo+sFilterDelay, mT.cbegin(), tmpiter,
 247         [](const float d, const float t) noexcept { return 0.828331f*d + 0.767820f*t; });
 248     std::copy_n(mTemp.cbegin()+SamplesToDo, mDTHistory.size(), mDTHistory.begin());
 249     PShift.process(xoutput.first(SamplesToDo), mTemp);
 250
 251     for(std::size_t i{0};i < SamplesToDo;++i)
 252     {
 253         /* W = 0.981532*S + 0.197484*j(0.828331*D + 0.767820*T) */
 254         woutput[i] = 0.981532f*mS[i] + 0.197484f*xoutput[i];
 255         /* X = 0.418496*S - j(0.828331*D + 0.767820*T) */
 256         xoutput[i] = 0.418496f*mS[i] - xoutput[i];
 257     }
 258
 259     /* Precompute j*S and store in youtput. */
 260     tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
 261     std::copy_n(mS.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
 262     std::copy_n(mTemp.cbegin()+SamplesToDo, mSHistory.size(), mSHistory.begin());
 263     PShift.process(youtput.first(SamplesToDo), mTemp);
 264
 265     for(std::size_t i{0};i < SamplesToDo;++i)
 266     {
 267         /* Y = 0.795968*D - 0.676392*T + j(0.186633*S) */
 268         youtput[i] = 0.795968f*mD[i] - 0.676392f*mT[i] + 0.186633f*youtput[i];
 269     }
 270
 271     if(OutSamples.size() > 3)
 272     {
 273         auto zoutput = al::span{OutSamples[3]};
 274         /* Z = 1.023332*Q */
 275         for(std::size_t i{0};i < SamplesToDo;++i)
 276             zoutput[i] = 1.023332f*mQ[i];
 277     }
 278
 279     std::copy(mS.begin()+SamplesToDo, mS.begin()+SamplesToDo+sFilterDelay, mS.begin());
 280     std::copy(mD.begin()+SamplesToDo, mD.begin()+SamplesToDo+sFilterDelay, mD.begin());
 281     std::copy(mT.begin()+SamplesToDo, mT.begin()+SamplesToDo+sFilterDelay, mT.begin());
 282     std::copy(mQ.begin()+SamplesToDo, mQ.begin()+SamplesToDo+sFilterDelay, mQ.begin());
 283 }
 284
 285 /* This is an alternative equation for decoding 2-channel UHJ. Not sure what
 286  * the intended benefit is over the above equation as this slightly reduces the
 287  * amount of the original left response and has more of the phase-shifted
 288  * forward response on the left response.
 289  *
 290  * This decoding is done as:
 291  *
 292  * S = Left + Right
 293  * D = Left - Right
 294  *
 295  * W = 0.981530*S + j*0.163585*D
 296  * X = 0.418504*S - j*0.828347*D
 297  * Y = 0.762956*D + j*0.384230*S
 298  *
 299  * where j is a +90 degree phase shift.
 300  *
 301  * NOTE: As above, S and D should not be halved. The only consequence of
 302  * halving here is merely a -6dB reduction in output, but it's still incorrect.
 303  */
 304 void UhjDecoder::decode2(const al::span<const float> InSamples,
 305     const al::span<FloatBufferLine> OutSamples, const std::size_t SamplesToDo)
 306 {
 307     ASSUME(SamplesToDo > 0);
 308
 309     auto woutput = al::span{OutSamples[0]};
 310     auto xoutput = al::span{OutSamples[1]};
 311     auto youtput = al::span{OutSamples[2]};
 312
 313     /* S = Left + Right */
 314     for(std::size_t i{0};i < SamplesToDo;++i)
 315         mS[sFilterDelay+i] = InSamples[i*2 + 0] + InSamples[i*2 + 1];
 316
 317     /* D = Left - Right */
 318     for(std::size_t i{0};i < SamplesToDo;++i)
 319         mD[sFilterDelay+i] = InSamples[i*2 + 0] - InSamples[i*2 + 1];
 320
 321     /* Precompute j*D and store in xoutput. */
 322     auto tmpiter = std::copy(mDTHistory.cbegin(), mDTHistory.cend(), mTemp.begin());
 323     std::copy_n(mD.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
 324     std::copy_n(mTemp.cbegin()+SamplesToDo, mDTHistory.size(), mDTHistory.begin());
 325     PShift.process(xoutput.first(SamplesToDo), mTemp);
 326
 327     for(std::size_t i{0};i < SamplesToDo;++i)
 328     {
 329         /* W = 0.981530*S + j*0.163585*D */
 330         woutput[i] = 0.981530f*mS[i] + 0.163585f*xoutput[i];
 331         /* X = 0.418504*S - j*0.828347*D */
 332         xoutput[i] = 0.418504f*mS[i] - 0.828347f*xoutput[i];
 333     }
 334
 335     /* Precompute j*S and store in youtput. */
 336     tmpiter = std::copy(mSHistory.cbegin(), mSHistory.cend(), mTemp.begin());
 337     std::copy_n(mS.cbegin(), SamplesToDo+sFilterDelay, tmpiter);
 338     std::copy_n(mTemp.cbegin()+SamplesToDo, mSHistory.size(), mSHistory.begin());
 339     PShift.process(youtput.first(SamplesToDo), mTemp);
 340
 341     for(std::size_t i{0};i < SamplesToDo;++i)
 342     {
 343         /* Y = 0.762956*D + j*0.384230*S */
 344         youtput[i] = 0.762956f*mD[i] + 0.384230f*youtput[i];
 345     }
 346
 347     std::copy(mS.begin()+SamplesToDo, mS.begin()+SamplesToDo+sFilterDelay, mS.begin());
 348     std::copy(mD.begin()+SamplesToDo, mD.begin()+SamplesToDo+sFilterDelay, mD.begin());
 349 }
 350
 351
 352 int main(al::span<std::string_view> args)
 353 {
 354     if(args.size() < 2 || args[1] == "-h" || args[1] == "--help")
 355     {
 356         printf("Usage: %.*s <[options] filename.wav...>\n\n"
 357             "  Options:\n"
 358             "    --general      Use the general equations for 2-channel UHJ (default).\n"
 359             "    --alternative  Use the alternative equations for 2-channel UHJ.\n"
 360             "\n"
 361             "Note: When decoding 2-channel UHJ to an .amb file, the result should not use\n"
 362             "the normal B-Format shelf filters! Only 3- and 4-channel UHJ can accurately\n"
 363             "reconstruct the original B-Format signal.",
 364             al::sizei(args[0]), args[0].data());
 365         return 1;
 366     }
 367
 368     std::size_t num_files{0}, num_decoded{0};
 369     bool use_general{true};
 370     for(size_t fidx{1};fidx < args.size();++fidx)
 371     {
 372         if(args[fidx] == "--general")
 373         {
 374             use_general = true;
 375             continue;
 376         }
 377         if(args[fidx] == "--alternative")
 378         {
 379             use_general = false;
 380             continue;
 381         }
 382         ++num_files;
 383         SF_INFO ininfo{};
 384         SndFilePtr infile{sf_open(std::string{args[fidx]}.c_str(), SFM_READ, &ininfo)};
 385         if(!infile)
 386         {
 387             fprintf(stderr, "Failed to open %.*s\n", al::sizei(args[fidx]), args[fidx].data());
 388             continue;
 389         }
 390         if(sf_command(infile.get(), SFC_WAVEX_GET_AMBISONIC, nullptr, 0) == SF_AMBISONIC_B_FORMAT)
 391         {
 392             fprintf(stderr, "%.*s is already B-Format\n", al::sizei(args[fidx]),
 393                 args[fidx].data());
 394             continue;
 395         }
 396         uint outchans{};
 397         if(ininfo.channels == 2)
 398             outchans = 3;
 399         else if(ininfo.channels == 3 || ininfo.channels == 4)
 400             outchans = static_cast<uint>(ininfo.channels);
 401         else
 402         {
 403             fprintf(stderr, "%.*s is not a 2-, 3-, or 4-channel file\n", al::sizei(args[fidx]),
 404                 args[fidx].data());
 405             continue;
 406         }
 407         printf("Converting %.*s from %d-channel UHJ%s...\n", al::sizei(args[fidx]),
 408             args[fidx].data(), ininfo.channels,
 409             (ininfo.channels == 2) ? use_general ? " (general)" : " (alternative)" : "");
 410
 411         std::string outname{args[fidx]};
 412         auto lastslash = outname.find_last_of('/');
 413         if(lastslash != std::string::npos)
 414             outname.erase(0, lastslash+1);
 415         auto lastdot = outname.find_last_of('.');
 416         if(lastdot != std::string::npos)
 417             outname.resize(lastdot+1);
 418         outname += "amb";
 419
 420         FilePtr outfile{fopen(outname.c_str(), "wb")};
 421         if(!outfile)
 422         {
 423             fprintf(stderr, "Failed to create %s\n", outname.c_str());
 424             continue;
 425         }
 426
 427         fputs("RIFF", outfile.get());
 428         fwrite32le(0xFFFFFFFF, outfile.get()); // 'RIFF' header len; filled in at close
 429
 430         fputs("WAVE", outfile.get());
 431
 432         fputs("fmt ", outfile.get());
 433         fwrite32le(40, outfile.get()); // 'fmt ' header len; 40 bytes for EXTENSIBLE
 434
 435         // 16-bit val, format type id (extensible: 0xFFFE)
 436         fwrite16le(0xFFFE, outfile.get());
 437         // 16-bit val, channel count
 438         fwrite16le(static_cast<ushort>(outchans), outfile.get());
 439         // 32-bit val, frequency
 440         fwrite32le(static_cast<uint>(ininfo.samplerate), outfile.get());
 441         // 32-bit val, bytes per second
 442         fwrite32le(static_cast<uint>(ininfo.samplerate)*outchans*uint{sizeof(float)}, outfile.get());
 443         // 16-bit val, frame size
 444         fwrite16le(static_cast<ushort>(sizeof(float)*outchans), outfile.get());
 445         // 16-bit val, bits per sample
 446         fwrite16le(static_cast<ushort>(sizeof(float)*8), outfile.get());
 447         // 16-bit val, extra byte count
 448         fwrite16le(22, outfile.get());
 449         // 16-bit val, valid bits per sample
 450         fwrite16le(static_cast<ushort>(sizeof(float)*8), outfile.get());
 451         // 32-bit val, channel mask
 452         fwrite32le(0, outfile.get());
 453         // 16 byte GUID, sub-type format
 454         fwrite(SUBTYPE_BFORMAT_FLOAT.data(), 1, SUBTYPE_BFORMAT_FLOAT.size(), outfile.get());
 455
 456         fputs("data", outfile.get());
 457         fwrite32le(0xFFFFFFFF, outfile.get()); // 'data' header len; filled in at close
 458         if(ferror(outfile.get()))
 459         {
 460             fprintf(stderr, "Error writing wave file header: %s (%d)\n",
 461                 std::generic_category().message(errno).c_str(), errno);
 462             continue;
 463         }
 464
 465         auto DataStart = ftell(outfile.get());
 466
 467         auto decoder = std::make_unique<UhjDecoder>();
 468         auto inmem = std::vector<float>(size_t{BufferLineSize}*static_cast<uint>(ininfo.channels));
 469         auto decmem = al::vector<std::array<float,BufferLineSize>, 16>(outchans);
 470         auto outmem = std::vector<byte4>(size_t{BufferLineSize}*outchans);
 471
 472         /* A number of initial samples need to be skipped to cut the lead-in
 473          * from the all-pass filter delay. The same number of samples need to
 474          * be fed through the decoder after reaching the end of the input file
 475          * to ensure none of the original input is lost.
 476          */
 477         std::size_t LeadIn{UhjDecoder::sFilterDelay};
 478         sf_count_t LeadOut{UhjDecoder::sFilterDelay};
 479         while(LeadOut > 0)
 480         {
 481             sf_count_t sgot{sf_readf_float(infile.get(), inmem.data(), BufferLineSize)};
 482             sgot = std::max<sf_count_t>(sgot, 0);
 483             if(sgot < BufferLineSize)
 484             {
 485                 const sf_count_t remaining{std::min(BufferLineSize - sgot, LeadOut)};
 486                 std::fill_n(inmem.begin() + sgot*ininfo.channels, remaining*ininfo.channels, 0.0f);
 487                 sgot += remaining;
 488                 LeadOut -= remaining;
 489             }
 490
 491             auto got = static_cast<std::size_t>(sgot);
 492             if(ininfo.channels > 2 || use_general)
 493                 decoder->decode(inmem, static_cast<uint>(ininfo.channels), decmem, got);
 494             else
 495                 decoder->decode2(inmem, decmem, got);
 496             if(LeadIn >= got)
 497             {
 498                 LeadIn -= got;
 499                 continue;
 500             }
 501
 502             got -= LeadIn;
 503             for(std::size_t i{0};i < got;++i)
 504             {
 505                 /* Attenuate by -3dB for FuMa output levels. */
 506                 constexpr auto inv_sqrt2 = static_cast<float>(1.0/al::numbers::sqrt2);
 507                 for(std::size_t j{0};j < outchans;++j)
 508                     outmem[i*outchans + j] = f32AsLEBytes(decmem[j][LeadIn+i] * inv_sqrt2);
 509             }
 510             LeadIn = 0;
 511
 512             std::size_t wrote{fwrite(outmem.data(), sizeof(byte4)*outchans, got, outfile.get())};
 513             if(wrote < got)
 514             {
 515                 fprintf(stderr, "Error writing wave data: %s (%d)\n",
 516                     std::generic_category().message(errno).c_str(), errno);
 517                 break;
 518             }
 519         }
 520
 521         auto DataEnd = ftell(outfile.get());
 522         if(DataEnd > DataStart)
 523         {
 524             long dataLen{DataEnd - DataStart};
 525             if(fseek(outfile.get(), 4, SEEK_SET) == 0)
 526                 fwrite32le(static_cast<uint>(DataEnd-8), outfile.get()); // 'WAVE' header len
 527             if(fseek(outfile.get(), DataStart-4, SEEK_SET) == 0)
 528                 fwrite32le(static_cast<uint>(dataLen), outfile.get()); // 'data' header len
 529         }
 530         fflush(outfile.get());
 531         ++num_decoded;
 532     }
 533     if(num_decoded == 0)
 534         fprintf(stderr, "Failed to decode any input files\n");
 535     else if(num_decoded < num_files)
 536         fprintf(stderr, "Decoded %zu of %zu files\n", num_decoded, num_files);
 537     else
 538         printf("Decoded %zu file%s\n", num_decoded, (num_decoded==1)?"":"s");
 539     return 0;
 540 }
 541
 542 } /* namespace */
 543
 544 int main(int argc, char *argv[])
 545 {
 546     assert(argc >= 0);
 547     auto args = std::vector<std::string_view>(static_cast<unsigned int>(argc));
 548     std::copy_n(argv, args.size(), args.begin());
 549     return main(al::span{args});
 550 }