alc/backends/solaris.cpp

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   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/solaris.h"
  24
  25 #include <sys/ioctl.h>
  26 #include <sys/types.h>
  27 #include <sys/time.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <memory.h>
  33 #include <unistd.h>
  34 #include <errno.h>
  35 #include <poll.h>
  36 #include <math.h>
  37
  38 #include <thread>
  39 #include <functional>
  40
  41 #include "alcmain.h"
  42 #include "alexcpt.h"
  43 #include "alu.h"
  44 #include "alconfig.h"
  45 #include "threads.h"
  46 #include "vector.h"
  47 #include "compat.h"
  48
  49 #include <sys/audioio.h>
  50
  51
  52 namespace {
  53
  54 constexpr ALCchar solaris_device[] = "Solaris Default";
  55
  56 std::string solaris_driver{"/dev/audio"};
  57
  58
  59 struct SolarisBackend final : public BackendBase {
  60     SolarisBackend(ALCdevice *device) noexcept : BackendBase{device} { }
  61     ~SolarisBackend() override;
  62
  63     int mixerProc();
  64
  65     void open(const ALCchar *name) override;
  66     bool reset() override;
  67     bool start() override;
  68     void stop() override;
  69
  70     int mFd{-1};
  71
  72     al::vector<ALubyte> mBuffer;
  73
  74     std::atomic<bool> mKillNow{true};
  75     std::thread mThread;
  76
  77     DEF_NEWDEL(SolarisBackend)
  78 };
  79
  80 SolarisBackend::~SolarisBackend()
  81 {
  82     if(mFd != -1)
  83         close(mFd);
  84     mFd = -1;
  85 }
  86
  87 int SolarisBackend::mixerProc()
  88 {
  89     SetRTPriority();
  90     althrd_setname(MIXER_THREAD_NAME);
  91
  92     const ALuint frame_size{mDevice->frameSizeFromFmt()};
  93
  94     std::unique_lock<SolarisBackend> dlock{*this};
  95     while(!mKillNow.load(std::memory_order_acquire) &&
  96           mDevice->Connected.load(std::memory_order_acquire))
  97     {
  98         pollfd pollitem{};
  99         pollitem.fd = mFd;
 100         pollitem.events = POLLOUT;
 101
 102         dlock.unlock();
 103         int pret{poll(&pollitem, 1, 1000)};
 104         dlock.lock();
 105         if(pret < 0)
 106         {
 107             if(errno == EINTR || errno == EAGAIN)
 108                 continue;
 109             ERR("poll failed: %s\n", strerror(errno));
 110             aluHandleDisconnect(mDevice, "Failed to wait for playback buffer: %s",
 111                 strerror(errno));
 112             break;
 113         }
 114         else if(pret == 0)
 115         {
 116             WARN("poll timeout\n");
 117             continue;
 118         }
 119
 120         ALubyte *write_ptr{mBuffer.data()};
 121         size_t to_write{mBuffer.size()};
 122         aluMixData(mDevice, write_ptr, to_write/frame_size);
 123         while(to_write > 0 && !mKillNow.load(std::memory_order_acquire))
 124         {
 125             ssize_t wrote{write(mFd, write_ptr, to_write)};
 126             if(wrote < 0)
 127             {
 128                 if(errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)
 129                     continue;
 130                 ERR("write failed: %s\n", strerror(errno));
 131                 aluHandleDisconnect(mDevice, "Failed to write playback samples: %s",
 132                     strerror(errno));
 133                 break;
 134             }
 135
 136             to_write -= wrote;
 137             write_ptr += wrote;
 138         }
 139     }
 140
 141     return 0;
 142 }
 143
 144
 145 void SolarisBackend::open(const ALCchar *name)
 146 {
 147     if(!name)
 148         name = solaris_device;
 149     else if(strcmp(name, solaris_device) != 0)
 150         throw al::backend_exception{ALC_INVALID_VALUE, "Device name \"%s\" not found", name};
 151
 152     mFd = ::open(solaris_driver.c_str(), O_WRONLY);
 153     if(mFd == -1)
 154         throw al::backend_exception{ALC_INVALID_VALUE, "Could not open %s: %s",
 155             solaris_driver.c_str(), strerror(errno)};
 156
 157     mDevice->DeviceName = name;
 158 }
 159
 160 bool SolarisBackend::reset()
 161 {
 162     audio_info_t info;
 163     AUDIO_INITINFO(&info);
 164
 165     info.play.sample_rate = mDevice->Frequency;
 166
 167     if(mDevice->FmtChans != DevFmtMono)
 168         mDevice->FmtChans = DevFmtStereo;
 169     ALuint numChannels{mDevice->channelsFromFmt()};
 170     info.play.channels = numChannels;
 171
 172     switch(mDevice->FmtType)
 173     {
 174         case DevFmtByte:
 175             info.play.precision = 8;
 176             info.play.encoding = AUDIO_ENCODING_LINEAR;
 177             break;
 178         case DevFmtUByte:
 179             info.play.precision = 8;
 180             info.play.encoding = AUDIO_ENCODING_LINEAR8;
 181             break;
 182         case DevFmtUShort:
 183         case DevFmtInt:
 184         case DevFmtUInt:
 185         case DevFmtFloat:
 186             mDevice->FmtType = DevFmtShort;
 187             /* fall-through */
 188         case DevFmtShort:
 189             info.play.precision = 16;
 190             info.play.encoding = AUDIO_ENCODING_LINEAR;
 191             break;
 192     }
 193
 194     ALuint frameSize{numChannels * mDevice->bytesFromFmt()};
 195     info.play.buffer_size = mDevice->BufferSize * frameSize;
 196
 197     if(ioctl(mFd, AUDIO_SETINFO, &info) < 0)
 198     {
 199         ERR("ioctl failed: %s\n", strerror(errno));
 200         return false;
 201     }
 202
 203     if(mDevice->channelsFromFmt() != info.play.channels)
 204     {
 205         ERR("Failed to set %s, got %u channels instead\n", DevFmtChannelsString(mDevice->FmtChans),
 206             info.play.channels);
 207         return false;
 208     }
 209
 210     if(!((info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR8 && mDevice->FmtType == DevFmtUByte) ||
 211          (info.play.precision == 8 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtByte) ||
 212          (info.play.precision == 16 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtShort) ||
 213          (info.play.precision == 32 && info.play.encoding == AUDIO_ENCODING_LINEAR && mDevice->FmtType == DevFmtInt)))
 214     {
 215         ERR("Could not set %s samples, got %d (0x%x)\n", DevFmtTypeString(mDevice->FmtType),
 216             info.play.precision, info.play.encoding);
 217         return false;
 218     }
 219
 220     mDevice->Frequency = info.play.sample_rate;
 221     mDevice->BufferSize = info.play.buffer_size / frameSize;
 222     mDevice->UpdateSize = mDevice->BufferSize / 2;
 223
 224     SetDefaultChannelOrder(mDevice);
 225
 226     mBuffer.resize(mDevice->UpdateSize * mDevice->frameSizeFromFmt());
 227     std::fill(mBuffer.begin(), mBuffer.end(), 0);
 228
 229     return true;
 230 }
 231
 232 bool SolarisBackend::start()
 233 {
 234     try {
 235         mKillNow.store(false, std::memory_order_release);
 236         mThread = std::thread{std::mem_fn(&SolarisBackend::mixerProc), this};
 237         return true;
 238     }
 239     catch(std::exception& e) {
 240         ERR("Could not create playback thread: %s\n", e.what());
 241     }
 242     catch(...) {
 243     }
 244     return false;
 245 }
 246
 247 void SolarisBackend::stop()
 248 {
 249     if(mKillNow.exchange(true, std::memory_order_acq_rel) || !mThread.joinable())
 250         return;
 251     mThread.join();
 252
 253     if(ioctl(mFd, AUDIO_DRAIN) < 0)
 254         ERR("Error draining device: %s\n", strerror(errno));
 255 }
 256
 257 } // namespace
 258
 259 BackendFactory &SolarisBackendFactory::getFactory()
 260 {
 261     static SolarisBackendFactory factory{};
 262     return factory;
 263 }
 264
 265 bool SolarisBackendFactory::init()
 266 {
 267     if(auto devopt = ConfigValueStr(nullptr, "solaris", "device"))
 268         solaris_driver = std::move(*devopt);
 269     return true;
 270 }
 271
 272 bool SolarisBackendFactory::querySupport(BackendType type)
 273 { return type == BackendType::Playback; }
 274
 275 void SolarisBackendFactory::probe(DevProbe type, std::string *outnames)
 276 {
 277     switch(type)
 278     {
 279         case DevProbe::Playback:
 280         {
 281 #ifdef HAVE_STAT
 282             struct stat buf;
 283             if(stat(solaris_driver.c_str(), &buf) == 0)
 284 #endif
 285                 outnames->append(solaris_device, sizeof(solaris_device));
 286         }
 287         break;
 288
 289         case DevProbe::Capture:
 290             break;
 291     }
 292 }
 293
 294 BackendPtr SolarisBackendFactory::createBackend(ALCdevice *device, BackendType type)
 295 {
 296     if(type == BackendType::Playback)
 297         return BackendPtr{new SolarisBackend{device}};
 298     return nullptr;
 299 }