1 files changed, 40 insertions, 38 deletions

diff --git a/Alc/backends/base.c b/Alc/backends/base.c
index fe797562..37e4ccc9 100644
--- a/Alc/backends/base.c
+++ b/Alc/backends/base.c
@@ -11,13 +11,15 @@
 /* Base ALCbackend method implementations. */
 void ALCbackend_Construct(ALCbackend *self, ALCdevice *device)
 {
+    int ret;
     self->mDevice = device;
-    InitializeCriticalSection(&self->mMutex);
+    ret = almtx_init(&self->mMutex, almtx_recursive);
+    assert(ret == althrd_success);
 }
 
 void ALCbackend_Destruct(ALCbackend *self)
 {
-    DeleteCriticalSection(&self->mMutex);
+    almtx_destroy(&self->mMutex);
 }
 
 ALCboolean ALCbackend_reset(ALCbackend* UNUSED(self))
@@ -42,12 +44,14 @@ ALint64 ALCbackend_getLatency(ALCbackend* UNUSED(self))
 
 void ALCbackend_lock(ALCbackend *self)
 {
-    EnterCriticalSection(&self->mMutex);
+    int ret = almtx_lock(&self->mMutex);
+    assert(ret == althrd_success);
 }
 
 void ALCbackend_unlock(ALCbackend *self)
 {
-    LeaveCriticalSection(&self->mMutex);
+    int ret = almtx_unlock(&self->mMutex);
+    assert(ret == althrd_success);
 }
 
 
@@ -60,9 +64,11 @@ void ALCbackendFactory_deinit(ALCbackendFactory* UNUSED(self))
 /* Wrappers to use an old-style backend with the new interface. */
 typedef struct PlaybackWrapper {
     DERIVE_FROM_TYPE(ALCbackend);
+
+    const BackendFuncs *Funcs;
 } PlaybackWrapper;
 
-static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device);
+static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, Destruct)
 static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name);
 static void PlaybackWrapper_close(PlaybackWrapper *self);
@@ -74,62 +80,61 @@ static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, ALCuint, availableSamples)
 static ALint64 PlaybackWrapper_getLatency(PlaybackWrapper *self);
 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, lock)
 static DECLARE_FORWARD(PlaybackWrapper, ALCbackend, void, unlock)
-static void PlaybackWrapper_Delete(PlaybackWrapper *self);
+DECLARE_DEFAULT_ALLOCATORS(PlaybackWrapper)
 DEFINE_ALCBACKEND_VTABLE(PlaybackWrapper);
 
-static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device)
+static void PlaybackWrapper_Construct(PlaybackWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
 {
     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
     SET_VTABLE2(PlaybackWrapper, ALCbackend, self);
+
+    self->Funcs = funcs;
 }
 
 static ALCenum PlaybackWrapper_open(PlaybackWrapper *self, const ALCchar *name)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->OpenPlayback(device, name);
+    return self->Funcs->OpenPlayback(device, name);
 }
 
 static void PlaybackWrapper_close(PlaybackWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    device->Funcs->ClosePlayback(device);
+    self->Funcs->ClosePlayback(device);
 }
 
 static ALCboolean PlaybackWrapper_reset(PlaybackWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->ResetPlayback(device);
+    return self->Funcs->ResetPlayback(device);
 }
 
 static ALCboolean PlaybackWrapper_start(PlaybackWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->StartPlayback(device);
+    return self->Funcs->StartPlayback(device);
 }
 
 static void PlaybackWrapper_stop(PlaybackWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    device->Funcs->StopPlayback(device);
+    self->Funcs->StopPlayback(device);
 }
 
 static ALint64 PlaybackWrapper_getLatency(PlaybackWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->GetLatency(device);
-}
-
-static void PlaybackWrapper_Delete(PlaybackWrapper *self)
-{
-    free(self);
+    return self->Funcs->GetLatency(device);
 }
 
 
 typedef struct CaptureWrapper {
     DERIVE_FROM_TYPE(ALCbackend);
+
+    const BackendFuncs *Funcs;
 } CaptureWrapper;
 
-static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device);
+static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs);
 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, Destruct)
 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name);
 static void CaptureWrapper_close(CaptureWrapper *self);
@@ -141,75 +146,72 @@ static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self);
 static ALint64 CaptureWrapper_getLatency(CaptureWrapper *self);
 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, lock)
 static DECLARE_FORWARD(CaptureWrapper, ALCbackend, void, unlock)
-static void CaptureWrapper_Delete(CaptureWrapper *self);
+DECLARE_DEFAULT_ALLOCATORS(CaptureWrapper)
 DEFINE_ALCBACKEND_VTABLE(CaptureWrapper);
 
 
-static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device)
+static void CaptureWrapper_Construct(CaptureWrapper *self, ALCdevice *device, const BackendFuncs *funcs)
 {
     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
     SET_VTABLE2(CaptureWrapper, ALCbackend, self);
+
+    self->Funcs = funcs;
 }
 
 static ALCenum CaptureWrapper_open(CaptureWrapper *self, const ALCchar *name)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->OpenCapture(device, name);
+    return self->Funcs->OpenCapture(device, name);
 }
 
 static void CaptureWrapper_close(CaptureWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    device->Funcs->CloseCapture(device);
+    self->Funcs->CloseCapture(device);
 }
 
 static ALCboolean CaptureWrapper_start(CaptureWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    device->Funcs->StartCapture(device);
+    self->Funcs->StartCapture(device);
     return ALC_TRUE;
 }
 
 static void CaptureWrapper_stop(CaptureWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    device->Funcs->StopCapture(device);
+    self->Funcs->StopCapture(device);
 }
 
 static ALCenum CaptureWrapper_captureSamples(CaptureWrapper *self, void *buffer, ALCuint samples)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->CaptureSamples(device, buffer, samples);
+    return self->Funcs->CaptureSamples(device, buffer, samples);
 }
 
 static ALCuint CaptureWrapper_availableSamples(CaptureWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->AvailableSamples(device);
+    return self->Funcs->AvailableSamples(device);
 }
 
 static ALint64 CaptureWrapper_getLatency(CaptureWrapper *self)
 {
     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
-    return device->Funcs->GetLatency(device);
-}
-
-static void CaptureWrapper_Delete(CaptureWrapper *self)
-{
-    free(self);
+    return self->Funcs->GetLatency(device);
 }
 
 
-ALCbackend *create_backend_wrapper(ALCdevice *device, ALCbackend_Type type)
+ALCbackend *create_backend_wrapper(ALCdevice *device, const BackendFuncs *funcs, ALCbackend_Type type)
 {
     if(type == ALCbackend_Playback)
     {
         PlaybackWrapper *backend;
 
-        backend = malloc(sizeof(*backend));
+        backend = PlaybackWrapper_New(sizeof(*backend));
         if(!backend) return NULL;
 
-        PlaybackWrapper_Construct(backend, device);
+        PlaybackWrapper_Construct(backend, device, funcs);
 
         return STATIC_CAST(ALCbackend, backend);
     }
@@ -218,10 +220,10 @@ ALCbackend *create_backend_wrapper(ALCdevice *device, ALCbackend_Type type)
     {
         CaptureWrapper *backend;
 
-        backend = malloc(sizeof(*backend));
+        backend = CaptureWrapper_New(sizeof(*backend));
         if(!backend) return NULL;
 
-        CaptureWrapper_Construct(backend, device);
+        CaptureWrapper_Construct(backend, device, funcs);
 
         return STATIC_CAST(ALCbackend, backend);
     }