Move the lock/unlock methods to the backend

2 files changed, 57 insertions, 0 deletions

diff --git a/Alc/ALc.c b/Alc/ALc.c
index 63dfa038..d2c28a05 100644
--- a/Alc/ALc.c
+++ b/Alc/ALc.c
@@ -153,6 +153,18 @@ static ALint64 BackendWrapper_getLatency(BackendWrapper *self)
     return device->Funcs->GetLatency(device);
 }
 
+static void BackendWrapper_lock(BackendWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return device->Funcs->Lock(device);
+}
+
+static void BackendWrapper_unlock(BackendWrapper *self)
+{
+    ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
+    return device->Funcs->Unlock(device);
+}
+
 static void BackendWrapper_Delete(BackendWrapper *self)
 {
     free(self);
@@ -1414,11 +1426,44 @@ ALint64 ALCdevice_GetLatencyDefault(ALCdevice *UNUSED(device))
     return 0;
 }
 
+
 ALint64 alcGetLatency(ALCdevice *device)
 {
     return VCALL0(device->Backend,getLatency,());
 }
 
+void ALCdevice_Lock(ALCdevice *device)
+{
+    return VCALL0(device->Backend,lock,());
+}
+
+void ALCdevice_Unlock(ALCdevice *device)
+{
+    return VCALL0(device->Backend,unlock,());
+}
+
+void LockContext(ALCcontext *context)
+{
+    VCALL0(context->Device->Backend,lock,());
+}
+
+void UnlockContext(ALCcontext *context)
+{
+    VCALL0(context->Device->Backend,unlock,());
+}
+
+
+void ALCbackend_lock(ALCbackend *self)
+{
+    ALCdevice_LockDefault(self->mDevice);
+}
+
+void ALCbackend_unlock(ALCbackend *self)
+{
+    ALCdevice_UnlockDefault(self->mDevice);
+}
+
+
 /* SetDefaultWFXChannelOrder
  *
  * Sets the default channel order used by WaveFormatEx.
diff --git a/Alc/backends/base.h b/Alc/backends/base.h
index 9cc0d66b..ed690f56 100644
--- a/Alc/backends/base.h
+++ b/Alc/backends/base.h
@@ -12,6 +12,9 @@ typedef struct ALCbackend {
     ALCdevice *mDevice;
 } ALCbackend;
 
+void ALCbackend_lock(ALCbackend *self);
+void ALCbackend_unlock(ALCbackend *self);
+
 struct ALCbackendVtable {
     void (*const Destruct)(ALCbackend *state);
 
@@ -24,6 +27,9 @@ struct ALCbackendVtable {
 
     ALint64 (*getLatency)(ALCbackend*);
 
+    void (*lock)(ALCbackend*);
+    void (*unlock)(ALCbackend*);
+
     void (*const Delete)(ALCbackend *state);
 };
 
@@ -42,6 +48,10 @@ static void T##_ALCbackend_stop(ALCbackend *obj)                              \
 { T##_stop(STATIC_UPCAST(T, ALCbackend, obj)); }                              \
 static ALint64 T##_ALCbackend_getLatency(ALCbackend *obj)                     \
 { return T##_getLatency(STATIC_UPCAST(T, ALCbackend, obj)); }                 \
+static void T##_ALCbackend_lock(ALCbackend *obj)                              \
+{ T##_lock(STATIC_UPCAST(T, ALCbackend, obj)); }                              \
+static void T##_ALCbackend_unlock(ALCbackend *obj)                            \
+{ T##_unlock(STATIC_UPCAST(T, ALCbackend, obj)); }                            \
 static void T##_ALCbackend_Delete(ALCbackend *obj)                            \
 { T##_Delete(STATIC_UPCAST(T, ALCbackend, obj)); }                            \
                                                                               \
@@ -54,6 +64,8 @@ static const struct ALCbackendVtable T##_ALCbackend_vtable = {                \
     T##_ALCbackend_start,                                                     \
     T##_ALCbackend_stop,                                                      \
     T##_ALCbackend_getLatency,                                                \
+    T##_ALCbackend_lock,                                                      \
+    T##_ALCbackend_unlock,                                                    \
                                                                               \
     T##_ALCbackend_Delete,                                                    \
 }