Alc/backends/base.c

   1
   2 #include "config.h"
   3
   4 #include <stdlib.h>
   5
   6 #include "alMain.h"
   7
   8 #include "backends/base.h"
   9
  10
  11 extern inline ALuint64 GetDeviceClockTime(ALCdevice *device);
  12
  13 /* Base ALCbackend method implementations. */
  14 void ALCbackend_Construct(ALCbackend *self, ALCdevice *device)
  15 {
  16     int ret;
  17     self->mDevice = device;
  18     ret = almtx_init(&self->mMutex, almtx_recursive);
  19     assert(ret == althrd_success);
  20 }
  21
  22 void ALCbackend_Destruct(ALCbackend *self)
  23 {
  24     almtx_destroy(&self->mMutex);
  25 }
  26
  27 ALCboolean ALCbackend_reset(ALCbackend* UNUSED(self))
  28 {
  29     return ALC_FALSE;
  30 }
  31
  32 ALCenum ALCbackend_captureSamples(ALCbackend* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples))
  33 {
  34     return ALC_INVALID_DEVICE;
  35 }
  36
  37 ALCuint ALCbackend_availableSamples(ALCbackend* UNUSED(self))
  38 {
  39     return 0;
  40 }
  41
  42 ClockLatency ALCbackend_getClockLatency(ALCbackend *self)
  43 {
  44     ALCdevice *device = self->mDevice;
  45     ClockLatency ret;
  46
  47     almtx_lock(&self->mMutex);
  48     ret.ClockTime = GetDeviceClockTime(device);
  49     // TODO: Perhaps should be NumUpdates-1 worth of UpdateSize?
  50     ret.Latency = 0;
  51     almtx_unlock(&self->mMutex);
  52
  53     return ret;
  54 }
  55
  56 void ALCbackend_lock(ALCbackend *self)
  57 {
  58     int ret = almtx_lock(&self->mMutex);
  59     assert(ret == althrd_success);
  60 }
  61
  62 void ALCbackend_unlock(ALCbackend *self)
  63 {
  64     int ret = almtx_unlock(&self->mMutex);
  65     assert(ret == althrd_success);
  66 }
  67
  68
  69 /* Base ALCbackendFactory method implementations. */
  70 void ALCbackendFactory_deinit(ALCbackendFactory* UNUSED(self))
  71 {
  72 }
  73
  74
  75 /* Wrappers to use an old-style backend with the new interface. */
  76 typedef struct PlaybackWrapper {
  77     DERIVE_FROM_TYPE(ALCbackend);
  78
  79     const BackendFuncs *Funcs;
  80 } PlaybackWrapper;
  81
  82 static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
  83 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, Destruct)
  84 static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name);
  85 static void PlaybackWrapper_close(PlaybackWrapper *self);
  86 static ALCboolean PlaybackWrapper_reset(PlaybackWrapper *self);
  87 static ALCboolean PlaybackWrapper_start(PlaybackWrapper *self);
  88 static void PlaybackWrapper_stop(PlaybackWrapper *self);
  89 static DECLARE_FORWARD2(PlaybackWrapper, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
  90 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, ALCuint, availableSamples)
  91 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, ClockLatency, getClockLatency)
  92 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, lock)
  93 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, unlock)
  94 DECLARE_DEFAULT_ALLOCATORS(PlaybackWrapper)
  95 DEFINE_ALCBACKEND_VTABLE(PlaybackWrapper);
  96
  97 static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
  98 {
  99     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 100     SET_VTABLE2(PlaybackWrapper, ALCbackend, self);
 101
 102     self->Funcs = funcs;
 103 }
 104
 105 static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name)
 106 {
 107     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 108     return self->Funcs->OpenPlayback(device, name);
 109 }
 110
 111 static void PlaybackWrapper_close(PlaybackWrapper *self)
 112 {
 113     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 114     self->Funcs->ClosePlayback(device);
 115 }
 116
 117 static ALCboolean PlaybackWrapper_reset(PlaybackWrapper *self)
 118 {
 119     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 120     return self->Funcs->ResetPlayback(device);
 121 }
 122
 123 static ALCboolean PlaybackWrapper_start(PlaybackWrapper *self)
 124 {
 125     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 126     return self->Funcs->StartPlayback(device);
 127 }
 128
 129 static void PlaybackWrapper_stop(PlaybackWrapper *self)
 130 {
 131     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 132     self->Funcs->StopPlayback(device);
 133 }
 134
 135
 136 typedef struct CaptureWrapper {
 137     DERIVE_FROM_TYPE(ALCbackend);
 138
 139     const BackendFuncs *Funcs;
 140 } CaptureWrapper;
 141
 142 static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
 143 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, Destruct)
 144 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name);
 145 static void CaptureWrapper_close(CaptureWrapper *self);
 146 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, ALCboolean, reset)
 147 static ALCboolean CaptureWrapper_start(CaptureWrapper *self);
 148 static void CaptureWrapper_stop(CaptureWrapper *self);
 149 static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples);
 150 static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self);
 151 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, ClockLatency, getClockLatency)
 152 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, lock)
 153 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, unlock)
 154 DECLARE_DEFAULT_ALLOCATORS(CaptureWrapper)
 155 DEFINE_ALCBACKEND_VTABLE(CaptureWrapper);
 156
 157 static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
 158 {
 159     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 160     SET_VTABLE2(CaptureWrapper, ALCbackend, self);
 161
 162     self->Funcs = funcs;
 163 }
 164
 165 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name)
 166 {
 167     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 168     return self->Funcs->OpenCapture(device, name);
 169 }
 170
 171 static void CaptureWrapper_close(CaptureWrapper *self)
 172 {
 173     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 174     self->Funcs->CloseCapture(device);
 175 }
 176
 177 static ALCboolean CaptureWrapper_start(CaptureWrapper *self)
 178 {
 179     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 180     self->Funcs->StartCapture(device);
 181     return ALC_TRUE;
 182 }
 183
 184 static void CaptureWrapper_stop(CaptureWrapper *self)
 185 {
 186     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 187     self->Funcs->StopCapture(device);
 188 }
 189
 190 static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples)
 191 {
 192     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 193     return self->Funcs->CaptureSamples(device, buffer, samples);
 194 }
 195
 196 static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self)
 197 {
 198     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 199     return self->Funcs->AvailableSamples(device);
 200 }
 201
 202
 203 ALCbackend *create_backend_wrapper(ALCdevice *device, const BackendFuncs *funcs, ALCbackend_Type type)
 204 {
 205     if(type == ALCbackend_Playback)
 206     {
 207         PlaybackWrapper *backend;
 208
 209         NEW_OBJ(backend, PlaybackWrapper)(device, funcs);
 210         if(!backend) return NULL;
 211
 212         return STATIC_CAST(ALCbackend, backend);
 213     }
 214
 215     if(type == ALCbackend_Capture)
 216     {
 217         CaptureWrapper *backend;
 218
 219         NEW_OBJ(backend, CaptureWrapper)(device, funcs);
 220         if(!backend) return NULL;
 221
 222         return STATIC_CAST(ALCbackend, backend);
 223     }
 224
 225     return NULL;
 226 }