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