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