alc/backends/null.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2010 by Chris Robinson
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "backends/null.h"
  24
  25 #include <exception>
  26 #include <atomic>
  27 #include <chrono>
  28 #include <cstdint>
  29 #include <cstring>
  30 #include <functional>
  31 #include <thread>
  32
  33 #include "alcmain.h"
  34 #include "almalloc.h"
  35 #include "alu.h"
  36 #include "logging.h"
  37 #include "threads.h"
  38
  39
  40 namespace {
  41
  42 using std::chrono::seconds;
  43 using std::chrono::milliseconds;
  44 using std::chrono::nanoseconds;
  45
  46 constexpr ALCchar nullDevice[] = "No Output";
  47
  48
  49 struct NullBackend final : public BackendBase {
  50     NullBackend(ALCdevice *device) noexcept : BackendBase{device} { }
  51
  52     int mixerProc();
  53
  54     ALCenum open(const ALCchar *name) override;
  55     bool reset() override;
  56     bool start() override;
  57     void stop() override;
  58
  59     std::atomic<bool> mKillNow{true};
  60     std::thread mThread;
  61
  62     DEF_NEWDEL(NullBackend)
  63 };
  64
  65 int NullBackend::mixerProc()
  66 {
  67     const milliseconds restTime{mDevice->UpdateSize*1000/mDevice->Frequency / 2};
  68
  69     SetRTPriority();
  70     althrd_setname(MIXER_THREAD_NAME);
  71
  72     int64_t done{0};
  73     auto start = std::chrono::steady_clock::now();
  74     while(!mKillNow.load(std::memory_order_acquire) &&
  75           mDevice->Connected.load(std::memory_order_acquire))
  76     {
  77         auto now = std::chrono::steady_clock::now();
  78
  79         /* This converts from nanoseconds to nanosamples, then to samples. */
  80         int64_t avail{std::chrono::duration_cast<seconds>((now-start) * mDevice->Frequency).count()};
  81         if(avail-done < mDevice->UpdateSize)
  82         {
  83             std::this_thread::sleep_for(restTime);
  84             continue;
  85         }
  86         while(avail-done >= mDevice->UpdateSize)
  87         {
  88             lock();
  89             aluMixData(mDevice, nullptr, mDevice->UpdateSize);
  90             unlock();
  91             done += mDevice->UpdateSize;
  92         }
  93
  94         /* For every completed second, increment the start time and reduce the
  95          * samples done. This prevents the difference between the start time
  96          * and current time from growing too large, while maintaining the
  97          * correct number of samples to render.
  98          */
  99         if(done >= mDevice->Frequency)
 100         {
 101             seconds s{done/mDevice->Frequency};
 102             start += s;
 103             done -= mDevice->Frequency*s.count();
 104         }
 105     }
 106
 107     return 0;
 108 }
 109
 110
 111 ALCenum NullBackend::open(const ALCchar *name)
 112 {
 113     if(!name)
 114         name = nullDevice;
 115     else if(strcmp(name, nullDevice) != 0)
 116         return ALC_INVALID_VALUE;
 117
 118     mDevice->DeviceName = name;
 119
 120     return ALC_NO_ERROR;
 121 }
 122
 123 bool NullBackend::reset()
 124 {
 125     SetDefaultWFXChannelOrder(mDevice);
 126     return true;
 127 }
 128
 129 bool NullBackend::start()
 130 {
 131     try {
 132         mKillNow.store(false, std::memory_order_release);
 133         mThread = std::thread{std::mem_fn(&NullBackend::mixerProc), this};
 134         return true;
 135     }
 136     catch(std::exception& e) {
 137         ERR("Failed to start mixing thread: %s\n", e.what());
 138     }
 139     catch(...) {
 140     }
 141     return false;
 142 }
 143
 144 void NullBackend::stop()
 145 {
 146     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 147         return;
 148     mThread.join();
 149 }
 150
 151 } // namespace
 152
 153
 154 bool NullBackendFactory::init()
 155 { return true; }
 156
 157 bool NullBackendFactory::querySupport(BackendType type)
 158 { return (type == BackendType::Playback); }
 159
 160 void NullBackendFactory::probe(DevProbe type, std::string *outnames)
 161 {
 162     switch(type)
 163     {
 164         case DevProbe::Playback:
 165             /* Includes null char. */
 166             outnames->append(nullDevice, sizeof(nullDevice));
 167             break;
 168         case DevProbe::Capture:
 169             break;
 170     }
 171 }
 172
 173 BackendPtr NullBackendFactory::createBackend(ALCdevice *device, BackendType type)
 174 {
 175     if(type == BackendType::Playback)
 176         return BackendPtr{new NullBackend{device}};
 177     return nullptr;
 178 }
 179
 180 BackendFactory &NullBackendFactory::getFactory()
 181 {
 182     static NullBackendFactory factory{};
 183     return factory;
 184 }