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 "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 "althrd_setname.h"
  34 #include "almalloc.h"
  35 #include "core/device.h"
  36 #include "core/helpers.h"
  37
  38
  39 namespace {
  40
  41 using std::chrono::seconds;
  42 using std::chrono::milliseconds;
  43 using std::chrono::nanoseconds;
  44 using namespace std::string_view_literals;
  45
  46 [[nodiscard]] constexpr auto GetDeviceName() noexcept { return "No Output"sv; }
  47
  48
  49 struct NullBackend final : public BackendBase {
  50     NullBackend(DeviceBase *device) noexcept : BackendBase{device} { }
  51
  52     int mixerProc();
  53
  54     void open(std::string_view name) override;
  55     bool reset() override;
  56     void start() override;
  57     void stop() override;
  58
  59     std::atomic<bool> mKillNow{true};
  60     std::thread mThread;
  61 };
  62
  63 int NullBackend::mixerProc()
  64 {
  65     const milliseconds restTime{mDevice->UpdateSize*1000/mDevice->Frequency / 2};
  66
  67     SetRTPriority();
  68     althrd_setname(MIXER_THREAD_NAME);
  69
  70     int64_t done{0};
  71     auto start = std::chrono::steady_clock::now();
  72     while(!mKillNow.load(std::memory_order_acquire)
  73         && mDevice->Connected.load(std::memory_order_acquire))
  74     {
  75         auto now = std::chrono::steady_clock::now();
  76
  77         /* This converts from nanoseconds to nanosamples, then to samples. */
  78         int64_t avail{std::chrono::duration_cast<seconds>((now-start) * mDevice->Frequency).count()};
  79         if(avail-done < mDevice->UpdateSize)
  80         {
  81             std::this_thread::sleep_for(restTime);
  82             continue;
  83         }
  84         while(avail-done >= mDevice->UpdateSize)
  85         {
  86             mDevice->renderSamples(nullptr, mDevice->UpdateSize, 0u);
  87             done += mDevice->UpdateSize;
  88         }
  89
  90         /* For every completed second, increment the start time and reduce the
  91          * samples done. This prevents the difference between the start time
  92          * and current time from growing too large, while maintaining the
  93          * correct number of samples to render.
  94          */
  95         if(done >= mDevice->Frequency)
  96         {
  97             seconds s{done/mDevice->Frequency};
  98             start += s;
  99             done -= mDevice->Frequency*s.count();
 100         }
 101     }
 102
 103     return 0;
 104 }
 105
 106
 107 void NullBackend::open(std::string_view name)
 108 {
 109     if(name.empty())
 110         name = GetDeviceName();
 111     else if(name != GetDeviceName())
 112         throw al::backend_exception{al::backend_error::NoDevice, "Device name \"%.*s\" not found",
 113             static_cast<int>(name.length()), name.data()};
 114
 115     mDevice->DeviceName = name;
 116 }
 117
 118 bool NullBackend::reset()
 119 {
 120     setDefaultWFXChannelOrder();
 121     return true;
 122 }
 123
 124 void NullBackend::start()
 125 {
 126     try {
 127         mKillNow.store(false, std::memory_order_release);
 128         mThread = std::thread{std::mem_fn(&NullBackend::mixerProc), this};
 129     }
 130     catch(std::exception& e) {
 131         throw al::backend_exception{al::backend_error::DeviceError,
 132             "Failed to start mixing thread: %s", e.what()};
 133     }
 134 }
 135
 136 void NullBackend::stop()
 137 {
 138     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 139         return;
 140     mThread.join();
 141 }
 142
 143 } // namespace
 144
 145
 146 bool NullBackendFactory::init()
 147 { return true; }
 148
 149 bool NullBackendFactory::querySupport(BackendType type)
 150 { return (type == BackendType::Playback); }
 151
 152 std::string NullBackendFactory::probe(BackendType type)
 153 {
 154     switch(type)
 155     {
 156     case BackendType::Playback:
 157         /* Include null char. */
 158         return std::string{GetDeviceName()} + '\0';
 159     case BackendType::Capture:
 160         break;
 161     }
 162     return std::string{};
 163 }
 164
 165 BackendPtr NullBackendFactory::createBackend(DeviceBase *device, BackendType type)
 166 {
 167     if(type == BackendType::Playback)
 168         return BackendPtr{new NullBackend{device}};
 169     return nullptr;
 170 }
 171
 172 BackendFactory &NullBackendFactory::getFactory()
 173 {
 174     static NullBackendFactory factory{};
 175     return factory;
 176 }