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 DECLARE_FORWARD(PlaybackWrapper, ALCbackend, ALint64, getLatency)
  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
 125 typedef struct CaptureWrapper {
 126     DERIVE_FROM_TYPE(ALCbackend);
 127
 128     const BackendFuncs *Funcs;
 129 } CaptureWrapper;
 130
 131 static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
 132 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, Destruct)
 133 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name);
 134 static void CaptureWrapper_close(CaptureWrapper *self);
 135 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, ALCboolean, reset)
 136 static ALCboolean CaptureWrapper_start(CaptureWrapper *self);
 137 static void CaptureWrapper_stop(CaptureWrapper *self);
 138 static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples);
 139 static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self);
 140 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, ALint64, getLatency)
 141 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, lock)
 142 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, unlock)
 143 DECLARE_DEFAULT_ALLOCATORS(CaptureWrapper)
 144 DEFINE_ALCBACKEND_VTABLE(CaptureWrapper);
 145
 146 static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
 147 {
 148     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 149     SET_VTABLE2(CaptureWrapper, ALCbackend, self);
 150
 151     self->Funcs = funcs;
 152 }
 153
 154 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name)
 155 {
 156     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 157     return self->Funcs->OpenCapture(device, name);
 158 }
 159
 160 static void CaptureWrapper_close(CaptureWrapper *self)
 161 {
 162     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 163     self->Funcs->CloseCapture(device);
 164 }
 165
 166 static ALCboolean CaptureWrapper_start(CaptureWrapper *self)
 167 {
 168     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 169     self->Funcs->StartCapture(device);
 170     return ALC_TRUE;
 171 }
 172
 173 static void CaptureWrapper_stop(CaptureWrapper *self)
 174 {
 175     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 176     self->Funcs->StopCapture(device);
 177 }
 178
 179 static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples)
 180 {
 181     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 182     return self->Funcs->CaptureSamples(device, buffer, samples);
 183 }
 184
 185 static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self)
 186 {
 187     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 188     return self->Funcs->AvailableSamples(device);
 189 }
 190
 191
 192 ALCbackend *create_backend_wrapper(ALCdevice *device, const BackendFuncs *funcs, ALCbackend_Type type)
 193 {
 194     if(type == ALCbackend_Playback)
 195     {
 196         PlaybackWrapper *backend;
 197
 198         backend = PlaybackWrapper_New(sizeof(*backend));
 199         if(!backend) return NULL;
 200
 201         PlaybackWrapper_Construct(backend, device, funcs);
 202
 203         return STATIC_CAST(ALCbackend, backend);
 204     }
 205
 206     if(type == ALCbackend_Capture)
 207     {
 208         CaptureWrapper *backend;
 209
 210         backend = CaptureWrapper_New(sizeof(*backend));
 211         if(!backend) return NULL;
 212
 213         CaptureWrapper_Construct(backend, device, funcs);
 214
 215         return STATIC_CAST(ALCbackend, backend);
 216     }
 217
 218     return NULL;
 219 }