Alc/backends/base.cpp

   1
   2 #include "config.h"
   3
   4 #include <stdlib.h>
   5
   6 #include <thread>
   7
   8 #include "alMain.h"
   9 #include "alu.h"
  10
  11 #include "backends/base.h"
  12
  13
  14 void ALCdevice_Lock(ALCdevice *device)
  15 { V0(device->Backend,lock)(); }
  16
  17 void ALCdevice_Unlock(ALCdevice *device)
  18 { V0(device->Backend,unlock)(); }
  19
  20 ClockLatency GetClockLatency(ALCdevice *device)
  21 {
  22     ClockLatency ret = V0(device->Backend,getClockLatency)();
  23     ret.Latency += device->FixedLatency;
  24     return ret;
  25 }
  26
  27
  28 /* Base ALCbackend method implementations. */
  29 void ALCbackend_Construct(ALCbackend *self, ALCdevice *device)
  30 {
  31     self->mDevice = device;
  32 }
  33
  34 void ALCbackend_Destruct(ALCbackend* UNUSED(self))
  35 {
  36 }
  37
  38 ALCboolean ALCbackend_reset(ALCbackend* UNUSED(self))
  39 {
  40     return ALC_FALSE;
  41 }
  42
  43 ALCenum ALCbackend_captureSamples(ALCbackend* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples))
  44 {
  45     return ALC_INVALID_DEVICE;
  46 }
  47
  48 ALCuint ALCbackend_availableSamples(ALCbackend* UNUSED(self))
  49 {
  50     return 0;
  51 }
  52
  53 ClockLatency ALCbackend_getClockLatency(ALCbackend *self)
  54 {
  55     ALCdevice *device = self->mDevice;
  56     ALuint refcount;
  57     ClockLatency ret;
  58
  59     do {
  60         while(((refcount=device->MixCount.load(std::memory_order_acquire))&1))
  61             std::this_thread::yield();
  62         ret.ClockTime = GetDeviceClockTime(device);
  63         std::atomic_thread_fence(std::memory_order_acquire);
  64     } while(refcount != device->MixCount.load(std::memory_order_relaxed));
  65
  66     /* NOTE: The device will generally have about all but one periods filled at
  67      * any given time during playback. Without a more accurate measurement from
  68      * the output, this is an okay approximation.
  69      */
  70     ret.Latency  = std::chrono::seconds{device->UpdateSize*maxi(device->NumUpdates-1, 0)};
  71     ret.Latency /= device->Frequency;
  72
  73     return ret;
  74 }
  75
  76 void ALCbackend_lock(ALCbackend *self)
  77 {
  78     try {
  79         self->mMutex.lock();
  80     }
  81     catch(...) {
  82         std::terminate();
  83     }
  84 }
  85
  86 void ALCbackend_unlock(ALCbackend *self)
  87 {
  88     try {
  89         self->mMutex.unlock();
  90     }
  91     catch(...) {
  92         std::terminate();
  93     }
  94 }