Rename Alc to alc

2019-07-28 18:56:04 -07:00
parent 93e60919c8
commit cb3e96e756
98 changed files with 95 additions and 91 deletions
@@ -0,0 +1,402 @@
+/**
+ * OpenAL cross platform audio library
+ * Copyright (C) 1999-2007 by authors.
+ * This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Library General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ *  License along with this library; if not, write to the
+ *  Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * Or go to http://www.gnu.org/copyleft/lgpl.html
+ */
+
+#include "config.h"
+
+#include "backends/wave.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+#include <exception>
+#include <functional>
+#include <thread>
+
+#include "AL/al.h"
+
+#include "alcmain.h"
+#include "alconfig.h"
+#include "almalloc.h"
+#include "alnumeric.h"
+#include "alu.h"
+#include "compat.h"
+#include "logging.h"
+#include "threads.h"
+#include "vector.h"
+
+
+namespace {
+
+using std::chrono::seconds;
+using std::chrono::milliseconds;
+using std::chrono::nanoseconds;
+
+constexpr ALCchar waveDevice[] = "Wave File Writer";
+
+constexpr ALubyte SUBTYPE_PCM[]{
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
+    0x00, 0x38, 0x9b, 0x71
+};
+constexpr ALubyte SUBTYPE_FLOAT[]{
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xaa,
+    0x00, 0x38, 0x9b, 0x71
+};
+
+constexpr ALubyte SUBTYPE_BFORMAT_PCM[]{
+    0x01, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
+    0xca, 0x00, 0x00, 0x00
+};
+
+constexpr ALubyte SUBTYPE_BFORMAT_FLOAT[]{
+    0x03, 0x00, 0x00, 0x00, 0x21, 0x07, 0xd3, 0x11, 0x86, 0x44, 0xc8, 0xc1,
+    0xca, 0x00, 0x00, 0x00
+};
+
+void fwrite16le(ALushort val, FILE *f)
+{
+    ALubyte data[2]{ static_cast<ALubyte>(val&0xff), static_cast<ALubyte>((val>>8)&0xff) };
+    fwrite(data, 1, 2, f);
+}
+
+void fwrite32le(ALuint val, FILE *f)
+{
+    ALubyte data[4]{ static_cast<ALubyte>(val&0xff), static_cast<ALubyte>((val>>8)&0xff),
+        static_cast<ALubyte>((val>>16)&0xff), static_cast<ALubyte>((val>>24)&0xff) };
+    fwrite(data, 1, 4, f);
+}
+
+
+struct WaveBackend final : public BackendBase {
+    WaveBackend(ALCdevice *device) noexcept : BackendBase{device} { }
+    ~WaveBackend() override;
+
+    int mixerProc();
+
+    ALCenum open(const ALCchar *name) override;
+    ALCboolean reset() override;
+    ALCboolean start() override;
+    void stop() override;
+
+    FILE *mFile{nullptr};
+    long mDataStart{-1};
+
+    al::vector<ALbyte> mBuffer;
+
+    std::atomic<bool> mKillNow{true};
+    std::thread mThread;
+
+    DEF_NEWDEL(WaveBackend)
+};
+
+WaveBackend::~WaveBackend()
+{
+    if(mFile)
+        fclose(mFile);
+    mFile = nullptr;
+}
+
+int WaveBackend::mixerProc()
+{
+    const milliseconds restTime{mDevice->UpdateSize*1000/mDevice->Frequency / 2};
+
+    althrd_setname(MIXER_THREAD_NAME);
+
+    const ALsizei frameSize{mDevice->frameSizeFromFmt()};
+
+    int64_t done{0};
+    auto start = std::chrono::steady_clock::now();
+    while(!mKillNow.load(std::memory_order_acquire) &&
+          mDevice->Connected.load(std::memory_order_acquire))
+    {
+        auto now = std::chrono::steady_clock::now();
+
+        /* This converts from nanoseconds to nanosamples, then to samples. */
+        int64_t avail{std::chrono::duration_cast<seconds>((now-start) *
+            mDevice->Frequency).count()};
+        if(avail-done < mDevice->UpdateSize)
+        {
+            std::this_thread::sleep_for(restTime);
+            continue;
+        }
+        while(avail-done >= mDevice->UpdateSize)
+        {
+            lock();
+            aluMixData(mDevice, mBuffer.data(), mDevice->UpdateSize);
+            unlock();
+            done += mDevice->UpdateSize;
+
+            if(!IS_LITTLE_ENDIAN)
+            {
+                const ALsizei bytesize{mDevice->bytesFromFmt()};
+                ALsizei i;
+
+                if(bytesize == 2)
+                {
+                    ALushort *samples = reinterpret_cast<ALushort*>(mBuffer.data());
+                    const auto len = static_cast<ALsizei>(mBuffer.size() / 2);
+                    for(i = 0;i < len;i++)
+                    {
+                        ALushort samp = samples[i];
+                        samples[i] = (samp>>8) | (samp<<8);
+                    }
+                }
+                else if(bytesize == 4)
+                {
+                    ALuint *samples = reinterpret_cast<ALuint*>(mBuffer.data());
+                    const auto len = static_cast<ALsizei>(mBuffer.size() / 4);
+                    for(i = 0;i < len;i++)
+                    {
+                        ALuint samp = samples[i];
+                        samples[i] = (samp>>24) | ((samp>>8)&0x0000ff00) |
+                                     ((samp<<8)&0x00ff0000) | (samp<<24);
+                    }
+                }
+            }
+
+            size_t fs{fwrite(mBuffer.data(), frameSize, mDevice->UpdateSize, mFile)};
+            (void)fs;
+            if(ferror(mFile))
+            {
+                ERR("Error writing to file\n");
+                aluHandleDisconnect(mDevice, "Failed to write playback samples");
+                break;
+            }
+        }
+
+        /* For every completed second, increment the start time and reduce the
+         * samples done. This prevents the difference between the start time
+         * and current time from growing too large, while maintaining the
+         * correct number of samples to render.
+         */
+        if(done >= mDevice->Frequency)
+        {
+            seconds s{done/mDevice->Frequency};
+            start += s;
+            done -= mDevice->Frequency*s.count();
+        }
+    }
+
+    return 0;
+}
+
+ALCenum WaveBackend::open(const ALCchar *name)
+{
+    const char *fname{GetConfigValue(nullptr, "wave", "file", "")};
+    if(!fname[0]) return ALC_INVALID_VALUE;
+
+    if(!name)
+        name = waveDevice;
+    else if(strcmp(name, waveDevice) != 0)
+        return ALC_INVALID_VALUE;
+
+#ifdef _WIN32
+    {
+        std::wstring wname = utf8_to_wstr(fname);
+        mFile = _wfopen(wname.c_str(), L"wb");
+    }
+#else
+    mFile = fopen(fname, "wb");
+#endif
+    if(!mFile)
+    {
+        ERR("Could not open file '%s': %s\n", fname, strerror(errno));
+        return ALC_INVALID_VALUE;
+    }
+
+    mDevice->DeviceName = name;
+
+    return ALC_NO_ERROR;
+}
+
+ALCboolean WaveBackend::reset()
+{
+    ALuint channels=0, bytes=0, chanmask=0;
+    int isbformat = 0;
+    size_t val;
+
+    fseek(mFile, 0, SEEK_SET);
+    clearerr(mFile);
+
+    if(GetConfigValueBool(nullptr, "wave", "bformat", 0))
+    {
+        mDevice->FmtChans = DevFmtAmbi3D;
+        mDevice->mAmbiOrder = 1;
+    }
+
+    switch(mDevice->FmtType)
+    {
+        case DevFmtByte:
+            mDevice->FmtType = DevFmtUByte;
+            break;
+        case DevFmtUShort:
+            mDevice->FmtType = DevFmtShort;
+            break;
+        case DevFmtUInt:
+            mDevice->FmtType = DevFmtInt;
+            break;
+        case DevFmtUByte:
+        case DevFmtShort:
+        case DevFmtInt:
+        case DevFmtFloat:
+            break;
+    }
+    switch(mDevice->FmtChans)
+    {
+        case DevFmtMono:   chanmask = 0x04; break;
+        case DevFmtStereo: chanmask = 0x01 | 0x02; break;
+        case DevFmtQuad:   chanmask = 0x01 | 0x02 | 0x10 | 0x20; break;
+        case DevFmtX51: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x200 | 0x400; break;
+        case DevFmtX51Rear: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020; break;
+        case DevFmtX61: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x100 | 0x200 | 0x400; break;
+        case DevFmtX71: chanmask = 0x01 | 0x02 | 0x04 | 0x08 | 0x010 | 0x020 | 0x200 | 0x400; break;
+        case DevFmtAmbi3D:
+            /* .amb output requires FuMa */
+            mDevice->mAmbiOrder = mini(mDevice->mAmbiOrder, 3);
+            mDevice->mAmbiLayout = AmbiLayout::FuMa;
+            mDevice->mAmbiScale = AmbiNorm::FuMa;
+            isbformat = 1;
+            chanmask = 0;
+            break;
+    }
+    bytes = mDevice->bytesFromFmt();
+    channels = mDevice->channelsFromFmt();
+
+    rewind(mFile);
+
+    fputs("RIFF", mFile);
+    fwrite32le(0xFFFFFFFF, mFile); // 'RIFF' header len; filled in at close
+
+    fputs("WAVE", mFile);
+
+    fputs("fmt ", mFile);
+    fwrite32le(40, mFile); // 'fmt ' header len; 40 bytes for EXTENSIBLE
+
+    // 16-bit val, format type id (extensible: 0xFFFE)
+    fwrite16le(0xFFFE, mFile);
+    // 16-bit val, channel count
+    fwrite16le(channels, mFile);
+    // 32-bit val, frequency
+    fwrite32le(mDevice->Frequency, mFile);
+    // 32-bit val, bytes per second
+    fwrite32le(mDevice->Frequency * channels * bytes, mFile);
+    // 16-bit val, frame size
+    fwrite16le(channels * bytes, mFile);
+    // 16-bit val, bits per sample
+    fwrite16le(bytes * 8, mFile);
+    // 16-bit val, extra byte count
+    fwrite16le(22, mFile);
+    // 16-bit val, valid bits per sample
+    fwrite16le(bytes * 8, mFile);
+    // 32-bit val, channel mask
+    fwrite32le(chanmask, mFile);
+    // 16 byte GUID, sub-type format
+    val = fwrite((mDevice->FmtType == DevFmtFloat) ?
+                 (isbformat ? SUBTYPE_BFORMAT_FLOAT : SUBTYPE_FLOAT) :
+                 (isbformat ? SUBTYPE_BFORMAT_PCM : SUBTYPE_PCM), 1, 16, mFile);
+    (void)val;
+
+    fputs("data", mFile);
+    fwrite32le(0xFFFFFFFF, mFile); // 'data' header len; filled in at close
+
+    if(ferror(mFile))
+    {
+        ERR("Error writing header: %s\n", strerror(errno));
+        return ALC_FALSE;
+    }
+    mDataStart = ftell(mFile);
+
+    SetDefaultWFXChannelOrder(mDevice);
+
+    const ALuint bufsize{mDevice->frameSizeFromFmt() * mDevice->UpdateSize};
+    mBuffer.resize(bufsize);
+
+    return ALC_TRUE;
+}
+
+ALCboolean WaveBackend::start()
+{
+    try {
+        mKillNow.store(false, std::memory_order_release);
+        mThread = std::thread{std::mem_fn(&WaveBackend::mixerProc), this};
+        return ALC_TRUE;
+    }
+    catch(std::exception& e) {
+        ERR("Failed to start mixing thread: %s\n", e.what());
+    }
+    catch(...) {
+    }
+    return ALC_FALSE;
+}
+
+void WaveBackend::stop()
+{
+    if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
+        return;
+    mThread.join();
+
+    long size{ftell(mFile)};
+    if(size > 0)
+    {
+        long dataLen{size - mDataStart};
+        if(fseek(mFile, mDataStart-4, SEEK_SET) == 0)
+            fwrite32le(dataLen, mFile); // 'data' header len
+        if(fseek(mFile, 4, SEEK_SET) == 0)
+            fwrite32le(size-8, mFile); // 'WAVE' header len
+    }
+}
+
+} // namespace
+
+
+bool WaveBackendFactory::init()
+{ return true; }
+
+bool WaveBackendFactory::querySupport(BackendType type)
+{ return type == BackendType::Playback; }
+
+void WaveBackendFactory::probe(DevProbe type, std::string *outnames)
+{
+    switch(type)
+    {
+        case DevProbe::Playback:
+            /* Includes null char. */
+            outnames->append(waveDevice, sizeof(waveDevice));
+            break;
+        case DevProbe::Capture:
+            break;
+    }
+}
+
+BackendPtr WaveBackendFactory::createBackend(ALCdevice *device, BackendType type)
+{
+    if(type == BackendType::Playback)
+        return BackendPtr{new WaveBackend{device}};
+    return nullptr;
+}
+
+BackendFactory &WaveBackendFactory::getFactory()
+{
+    static WaveBackendFactory factory{};
+    return factory;
+}