Alc/backends/base.cpp

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