From 32e85d469b735260d827d50a6d37c0937d375914 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 7 Oct 2013 08:00:18 -0700 Subject: Use the UNUSED macro in the backends --- Alc/backends/loopback.c | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) (limited to 'Alc/backends/loopback.c') diff --git a/Alc/backends/loopback.c b/Alc/backends/loopback.c index e1bdd3c1..067e23d1 100644 --- a/Alc/backends/loopback.c +++ b/Alc/backends/loopback.c @@ -32,9 +32,8 @@ static ALCenum loopback_open_playback(ALCdevice *device, const ALCchar *deviceNa return ALC_NO_ERROR; } -static void loopback_close_playback(ALCdevice *device) +static void loopback_close_playback(ALCdevice *UNUSED(device)) { - (void)device; } static ALCboolean loopback_reset_playback(ALCdevice *device) @@ -43,15 +42,13 @@ static ALCboolean loopback_reset_playback(ALCdevice *device) return ALC_TRUE; } -static ALCboolean loopback_start_playback(ALCdevice *device) +static ALCboolean loopback_start_playback(ALCdevice *UNUSED(device)) { return ALC_TRUE; - (void)device; } -static void loopback_stop_playback(ALCdevice *device) +static void loopback_stop_playback(ALCdevice *UNUSED(device)) { - (void)device; } @@ -82,7 +79,6 @@ void alc_loopback_deinit(void) { } -void alc_loopback_probe(enum DevProbe type) +void alc_loopback_probe(enum DevProbe UNUSED(type)) { - (void)type; } -- cgit v1.2.3 From d2b36159431789d6934f5569e54982d7c54c4e84 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Tue, 29 Oct 2013 10:38:55 -0700 Subject: Convert the loopback backend to the new interface --- Alc/ALc.c | 18 ++++--- Alc/backends/base.h | 6 ++- Alc/backends/loopback.c | 120 +++++++++++++++++++++++++++++++++++----------- OpenAL32/Include/alMain.h | 3 -- 4 files changed, 109 insertions(+), 38 deletions(-) (limited to 'Alc/backends/loopback.c') diff --git a/Alc/ALc.c b/Alc/ALc.c index efbc4be5..266134c9 100644 --- a/Alc/ALc.c +++ b/Alc/ALc.c @@ -99,9 +99,6 @@ static struct BackendInfo BackendList[] = { { NULL, NULL, NULL, NULL, NULL, EmptyFuncs } }; -static struct BackendInfo BackendLoopback = { - "loopback", NULL, alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs -}; #undef EmptyFuncs static struct BackendInfo PlaybackBackend; @@ -1063,7 +1060,10 @@ static void alc_initconfig(void) TRACE("Added \"%s\" for capture\n", CaptureBackend.name); } } - BackendLoopback.Init(&BackendLoopback.Funcs); + { + ALCbackendFactory *factory = ALCloopbackFactory_getFactory(); + VCALL0(factory,init)(); + } if(ConfigValueStr(NULL, "excludefx", &str)) { @@ -1161,7 +1161,10 @@ static void alc_deinit(void) VCALL0(factory,deinit)(); } } - BackendLoopback.Deinit(); + { + ALCbackendFactory *factory = ALCloopbackFactory_getFactory(); + VCALL0(factory,deinit)(); + } alc_deinit_safe(); } @@ -3284,6 +3287,7 @@ ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, */ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceName) { + ALCbackendFactory *factory; ALCdevice *device; DO_INITCONFIG(); @@ -3303,7 +3307,6 @@ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceN } //Validate device - device->Funcs = &BackendLoopback.Funcs; device->ref = 1; device->Connected = ALC_TRUE; device->Type = Loopback; @@ -3324,7 +3327,8 @@ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceN InitUIntMap(&device->EffectMap, ~0); InitUIntMap(&device->FilterMap, ~0); - device->Backend = create_backend_wrapper(device, ALCbackend_Playback); + factory = ALCloopbackFactory_getFactory(); + device->Backend = VCALL(factory,createBackend)(device, ALCbackend_Playback); if(!device->Backend) { al_free(device); diff --git a/Alc/backends/base.h b/Alc/backends/base.h index 90c4d30f..a8917bec 100644 --- a/Alc/backends/base.h +++ b/Alc/backends/base.h @@ -42,6 +42,9 @@ struct ALCbackendVtable { void (*const Delete)(ALCbackend*); }; +#define DECLARE_ALCBACKEND_VTABLE(T) \ +static const struct ALCbackendVtable T##_ALCbackend_vtable + #define DEFINE_ALCBACKEND_VTABLE(T) \ static void T##_ALCbackend_Destruct(ALCbackend *obj) \ { T##_Destruct(STATIC_UPCAST(T, ALCbackend, obj)); } \ @@ -68,7 +71,7 @@ static void T##_ALCbackend_unlock(ALCbackend *obj) \ static void T##_ALCbackend_Delete(ALCbackend *obj) \ { T##_Delete(STATIC_UPCAST(T, ALCbackend, obj)); } \ \ -static const struct ALCbackendVtable T##_ALCbackend_vtable = { \ +DECLARE_ALCBACKEND_VTABLE(T) = { \ T##_ALCbackend_Destruct, \ \ T##_ALCbackend_open, \ @@ -132,6 +135,7 @@ static const struct ALCbackendFactoryVtable T##_ALCbackendFactory_vtable = { \ ALCbackendFactory *ALCalsaBackendFactory_getFactory(void); ALCbackendFactory *ALCnullBackendFactory_getFactory(void); +ALCbackendFactory *ALCloopbackFactory_getFactory(void); ALCbackend *create_backend_wrapper(ALCdevice *device, ALCbackend_Type type); diff --git a/Alc/backends/loopback.c b/Alc/backends/loopback.c index 067e23d1..bb5dd503 100644 --- a/Alc/backends/loopback.c +++ b/Alc/backends/loopback.c @@ -25,60 +25,126 @@ #include "alMain.h" #include "alu.h" +#include "backends/base.h" -static ALCenum loopback_open_playback(ALCdevice *device, const ALCchar *deviceName) + +typedef struct ALCloopback { + DERIVE_FROM_TYPE(ALCbackend); +} ALCloopback; +DECLARE_ALCBACKEND_VTABLE(ALCloopback); + +#define ALCNULLBACKEND_INITIALIZER { { GET_VTABLE2(ALCbackend, ALCloopback) } } + + +static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device) +{ + ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); + SET_VTABLE2(ALCloopback, ALCbackend, self); +} + +static void ALCloopback_Destruct(ALCloopback *self) +{ + ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); +} + +static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name) { - device->DeviceName = strdup(deviceName); + ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice; + + device->DeviceName = strdup(name); return ALC_NO_ERROR; } -static void loopback_close_playback(ALCdevice *UNUSED(device)) +static void ALCloopback_close(ALCloopback* UNUSED(self)) { } -static ALCboolean loopback_reset_playback(ALCdevice *device) +static ALCboolean ALCloopback_reset(ALCloopback *self) { - SetDefaultWFXChannelOrder(device); + SetDefaultWFXChannelOrder(STATIC_CAST(ALCbackend, self)->mDevice); return ALC_TRUE; } -static ALCboolean loopback_start_playback(ALCdevice *UNUSED(device)) +static ALCboolean ALCloopback_start(ALCloopback* UNUSED(self)) { return ALC_TRUE; } -static void loopback_stop_playback(ALCdevice *UNUSED(device)) +static void ALCloopback_stop(ALCloopback* UNUSED(self)) +{ +} + +ALCenum ALCloopback_captureSamples(ALCloopback* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples)) +{ + return ALC_INVALID_VALUE; +} + +ALCuint ALCloopback_availableSamples(ALCloopback* UNUSED(self)) { + return 0; } +static ALint64 ALCloopback_getLatency(ALCloopback *self) +{ return ALCbackend_getLatency(STATIC_CAST(ALCbackend, self)); } + +static void ALCloopback_lock(ALCloopback *self) +{ ALCbackend_lock(STATIC_CAST(ALCbackend, self)); } -static const BackendFuncs loopback_funcs = { - loopback_open_playback, - loopback_close_playback, - loopback_reset_playback, - loopback_start_playback, - loopback_stop_playback, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - ALCdevice_LockDefault, - ALCdevice_UnlockDefault, - ALCdevice_GetLatencyDefault -}; +static void ALCloopback_unlock(ALCloopback *self) +{ ALCbackend_unlock(STATIC_CAST(ALCbackend, self)); } -ALCboolean alc_loopback_init(BackendFuncs *func_list) +static void ALCloopback_Delete(ALCloopback *self) +{ + free(self); +} + +DEFINE_ALCBACKEND_VTABLE(ALCloopback); + + +typedef struct ALCloopbackFactory { + DERIVE_FROM_TYPE(ALCbackendFactory); +} ALCloopbackFactory; +#define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCloopbackFactory, ALCbackendFactory) } } + +ALCboolean ALCloopbackFactory_init(ALCloopbackFactory* UNUSED(self)) { - *func_list = loopback_funcs; return ALC_TRUE; } -void alc_loopback_deinit(void) +void ALCloopbackFactory_deinit(ALCloopbackFactory* UNUSED(self)) +{ +} + +ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory* UNUSED(self), ALCbackend_Type type) +{ + if(type == ALCbackend_Playback) + return ALC_TRUE; + return ALC_FALSE; +} + +void ALCloopbackFactory_probe(ALCloopbackFactory* UNUSED(self), enum DevProbe UNUSED(type)) { } -void alc_loopback_probe(enum DevProbe UNUSED(type)) +ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type) +{ + ALCloopback *backend; + + assert(type == ALCbackend_Playback); + + backend = calloc(1, sizeof(*backend)); + if(!backend) return NULL; + + ALCloopback_Construct(backend, device); + + return STATIC_CAST(ALCbackend, backend); +} + +DEFINE_ALCBACKENDFACTORY_VTABLE(ALCloopbackFactory); + + +ALCbackendFactory *ALCloopbackFactory_getFactory(void) { + static ALCloopbackFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER; + return STATIC_CAST(ALCbackendFactory, &factory); } diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h index 685536b5..a8175ce7 100644 --- a/OpenAL32/Include/alMain.h +++ b/OpenAL32/Include/alMain.h @@ -232,9 +232,6 @@ void alc_opensl_probe(enum DevProbe type); ALCboolean alc_qsa_init(BackendFuncs *func_list); void alc_qsa_deinit(void); void alc_qsa_probe(enum DevProbe type); -ALCboolean alc_loopback_init(BackendFuncs *func_list); -void alc_loopback_deinit(void); -void alc_loopback_probe(enum DevProbe type); struct ALCbackend; -- cgit v1.2.3 From d4aa4e16a0b6bb53ec9bbe0a8b3f467fb9a243f7 Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Tue, 29 Oct 2013 11:22:18 -0700 Subject: Add a macro to forward methods to a base type --- Alc/backends/alsa.c | 62 ++++++++++++++++++----------------------------- Alc/backends/loopback.c | 17 +++---------- Alc/backends/null.c | 39 ++++++++++------------------- OpenAL32/Include/alMain.h | 3 +++ 4 files changed, 43 insertions(+), 78 deletions(-) (limited to 'Alc/backends/loopback.c') diff --git a/Alc/backends/alsa.c b/Alc/backends/alsa.c index 0bed0d4b..586c1bf6 100644 --- a/Alc/backends/alsa.c +++ b/Alc/backends/alsa.c @@ -451,10 +451,12 @@ typedef struct ALCplaybackAlsa { volatile int killNow; althread_t thread; } ALCplaybackAlsa; +DECLARE_ALCBACKEND_VTABLE(ALCplaybackAlsa); static ALuint ALCplaybackAlsa_mixerProc(ALvoid *ptr); static ALuint ALCplaybackAlsa_mixerNoMMapProc(ALvoid *ptr); +static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, Destruct) static ALCenum ALCplaybackAlsa_open(ALCplaybackAlsa *self, const ALCchar *name); static void ALCplaybackAlsa_close(ALCplaybackAlsa *self); static ALCboolean ALCplaybackAlsa_reset(ALCplaybackAlsa *self); @@ -462,8 +464,15 @@ static ALCboolean ALCplaybackAlsa_start(ALCplaybackAlsa *self); static void ALCplaybackAlsa_stop(ALCplaybackAlsa *self); static ALCenum ALCplaybackAlsa_captureSamples(ALCplaybackAlsa *self, ALCvoid *buffer, ALCuint samples); static ALCuint ALCplaybackAlsa_availableSamples(ALCplaybackAlsa *self); -static void ALCplaybackAlsa_lock(ALCplaybackAlsa *self); -static void ALCplaybackAlsa_unlock(ALCplaybackAlsa *self); +static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, lock) +static DECLARE_FORWARD(ALCplaybackAlsa, ALCbackend, void, unlock) + + +static void ALCplaybackAlsa_Construct(ALCplaybackAlsa *self, ALCdevice *device) +{ + ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); + SET_VTABLE2(ALCplaybackAlsa, ALCbackend, self); +} static ALuint ALCplaybackAlsa_mixerProc(ALvoid *ptr) @@ -947,22 +956,6 @@ static ALint64 ALCplaybackAlsa_getLatency(ALCplaybackAlsa *self) return maxi64((ALint64)delay*1000000000/device->Frequency, 0); } -static void ALCplaybackAlsa_lock(ALCplaybackAlsa *self) -{ ALCbackend_lock(STATIC_CAST(ALCbackend, self)); } - -static void ALCplaybackAlsa_unlock(ALCplaybackAlsa *self) -{ ALCbackend_unlock(STATIC_CAST(ALCbackend, self)); } - - -static void ALCplaybackAlsa_Construct(ALCplaybackAlsa *self, ALCdevice *device) -{ - ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); -} - -static void ALCplaybackAlsa_Destruct(ALCplaybackAlsa *self) -{ - ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); -} static void ALCplaybackAlsa_Delete(ALCplaybackAlsa *self) { @@ -985,7 +978,9 @@ typedef struct ALCcaptureAlsa { snd_pcm_sframes_t last_avail; } ALCcaptureAlsa; +DECLARE_ALCBACKEND_VTABLE(ALCcaptureAlsa); +static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, Destruct) static ALCenum ALCcaptureAlsa_open(ALCcaptureAlsa *self, const ALCchar *name); static void ALCcaptureAlsa_close(ALCcaptureAlsa *self); static ALCboolean ALCcaptureAlsa_reset(ALCcaptureAlsa *self); @@ -993,8 +988,16 @@ static ALCboolean ALCcaptureAlsa_start(ALCcaptureAlsa *self); static void ALCcaptureAlsa_stop(ALCcaptureAlsa *self); static ALCenum ALCcaptureAlsa_captureSamples(ALCcaptureAlsa *self, ALCvoid *buffer, ALCuint samples); static ALCuint ALCcaptureAlsa_availableSamples(ALCcaptureAlsa *self); -static void ALCcaptureAlsa_lock(ALCcaptureAlsa *self); -static void ALCcaptureAlsa_unlock(ALCcaptureAlsa *self); +static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, lock) +static DECLARE_FORWARD(ALCcaptureAlsa, ALCbackend, void, unlock) + + +static void ALCcaptureAlsa_Construct(ALCcaptureAlsa *self, ALCdevice *device) +{ + ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); + SET_VTABLE2(ALCcaptureAlsa, ALCbackend, self); +} + static ALCenum ALCcaptureAlsa_open(ALCcaptureAlsa *self, const ALCchar *name) { @@ -1356,23 +1359,6 @@ static ALint64 ALCcaptureAlsa_getLatency(ALCcaptureAlsa *self) return maxi64((ALint64)delay*1000000000/device->Frequency, 0); } -static void ALCcaptureAlsa_lock(ALCcaptureAlsa *self) -{ ALCbackend_lock(STATIC_CAST(ALCbackend, self)); } - -static void ALCcaptureAlsa_unlock(ALCcaptureAlsa *self) -{ ALCbackend_unlock(STATIC_CAST(ALCbackend, self)); } - - -static void ALCcaptureAlsa_Construct(ALCcaptureAlsa *self, ALCdevice *device) -{ - ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); -} - -static void ALCcaptureAlsa_Destruct(ALCcaptureAlsa *self) -{ - ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); -} - static void ALCcaptureAlsa_Delete(ALCcaptureAlsa *self) { free(self); @@ -1474,7 +1460,6 @@ ALCbackend* ALCalsaBackendFactory_createBackend(ALCalsaBackendFactory* UNUSED(se backend = calloc(1, sizeof(*backend)); if(!backend) return NULL; - SET_VTABLE2(ALCplaybackAlsa, ALCbackend, backend); ALCplaybackAlsa_Construct(backend, device); @@ -1486,7 +1471,6 @@ ALCbackend* ALCalsaBackendFactory_createBackend(ALCalsaBackendFactory* UNUSED(se backend = calloc(1, sizeof(*backend)); if(!backend) return NULL; - SET_VTABLE2(ALCcaptureAlsa, ALCbackend, backend); ALCcaptureAlsa_Construct(backend, device); diff --git a/Alc/backends/loopback.c b/Alc/backends/loopback.c index bb5dd503..e400fcf2 100644 --- a/Alc/backends/loopback.c +++ b/Alc/backends/loopback.c @@ -33,7 +33,10 @@ typedef struct ALCloopback { } ALCloopback; DECLARE_ALCBACKEND_VTABLE(ALCloopback); -#define ALCNULLBACKEND_INITIALIZER { { GET_VTABLE2(ALCbackend, ALCloopback) } } +static DECLARE_FORWARD(ALCloopback, ALCbackend, void, Destruct) +static DECLARE_FORWARD(ALCloopback, ALCbackend, ALint64, getLatency) +static DECLARE_FORWARD(ALCloopback, ALCbackend, void, lock) +static DECLARE_FORWARD(ALCloopback, ALCbackend, void, unlock) static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device) @@ -42,10 +45,6 @@ static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device) SET_VTABLE2(ALCloopback, ALCbackend, self); } -static void ALCloopback_Destruct(ALCloopback *self) -{ - ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); -} static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name) { @@ -84,14 +83,6 @@ ALCuint ALCloopback_availableSamples(ALCloopback* UNUSED(self)) return 0; } -static ALint64 ALCloopback_getLatency(ALCloopback *self) -{ return ALCbackend_getLatency(STATIC_CAST(ALCbackend, self)); } - -static void ALCloopback_lock(ALCloopback *self) -{ ALCbackend_lock(STATIC_CAST(ALCbackend, self)); } - -static void ALCloopback_unlock(ALCloopback *self) -{ ALCbackend_unlock(STATIC_CAST(ALCbackend, self)); } static void ALCloopback_Delete(ALCloopback *self) { diff --git a/Alc/backends/null.c b/Alc/backends/null.c index c5b178de..8eeb2689 100644 --- a/Alc/backends/null.c +++ b/Alc/backends/null.c @@ -39,11 +39,23 @@ typedef struct ALCnullBackend { volatile int killNow; althread_t thread; } ALCnullBackend; -#define ALCNULLBACKEND_INITIALIZER { { GET_VTABLE2(ALCbackend, ALCnullBackend) } } +DECLARE_ALCBACKEND_VTABLE(ALCnullBackend); +static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, Destruct) +static DECLARE_FORWARD(ALCnullBackend, ALCbackend, ALint64, getLatency) +static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, lock) +static DECLARE_FORWARD(ALCnullBackend, ALCbackend, void, unlock) static const ALCchar nullDevice[] = "No Output"; + +static void ALCnullBackend_Construct(ALCnullBackend *self, ALCdevice *device) +{ + ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); + SET_VTABLE2(ALCnullBackend, ALCbackend, self); +} + + static ALuint ALCnullBackend_mixerProc(ALvoid *ptr) { ALCnullBackend *self = (ALCnullBackend*)ptr; @@ -86,16 +98,6 @@ static ALuint ALCnullBackend_mixerProc(ALvoid *ptr) } -static void ALCnullBackend_Construct(ALCnullBackend *self, ALCdevice *device) -{ - ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device); -} - -static void ALCnullBackend_Destruct(ALCnullBackend *self) -{ - ALCbackend_Destruct(STATIC_CAST(ALCbackend, self)); -} - static ALCenum ALCnullBackend_open(ALCnullBackend *self, const ALCchar *name) { ALCdevice *device; @@ -150,20 +152,6 @@ ALCuint ALCnullBackend_availableSamples(ALCnullBackend* UNUSED(self)) return 0; } -static ALint64 ALCnullBackend_getLatency(ALCnullBackend *self) -{ - return ALCbackend_getLatency(STATIC_CAST(ALCbackend, self)); -} - -static void ALCnullBackend_lock(ALCnullBackend *self) -{ - ALCbackend_lock(STATIC_CAST(ALCbackend, self)); -} - -static void ALCnullBackend_unlock(ALCnullBackend *self) -{ - ALCbackend_unlock(STATIC_CAST(ALCbackend, self)); -} static void ALCnullBackend_Delete(ALCnullBackend *self) { @@ -214,7 +202,6 @@ ALCbackend* ALCnullBackendFactory_createBackend(ALCnullBackendFactory* UNUSED(se backend = calloc(1, sizeof(*backend)); if(!backend) return NULL; - SET_VTABLE2(ALCnullBackend, ALCbackend, backend); ALCnullBackend_Construct(backend, device); diff --git a/OpenAL32/Include/alMain.h b/OpenAL32/Include/alMain.h index a8175ce7..81ed726b 100644 --- a/OpenAL32/Include/alMain.h +++ b/OpenAL32/Include/alMain.h @@ -102,6 +102,9 @@ static const union { #define SET_VTABLE1(T1, obj) ((obj)->vtbl = GET_VTABLE1(T1)) #define SET_VTABLE2(T1, T2, obj) (STATIC_CAST(T2, obj)->vtbl = GET_VTABLE2(T1, T2)) +#define DECLARE_FORWARD(T1, T2, rettype, func) \ +rettype T1##_##func(T1 *obj) \ +{ return T2##_##func(STATIC_CAST(T2, obj)); } /* Helper to extract an argument list for VCALL. Not used directly. */ #define EXTRACT_VCALL_ARGS(...) __VA_ARGS__)) -- cgit v1.2.3 From 94aeb5f52e656e021ce626ef523fb4a29cce117f Mon Sep 17 00:00:00 2001 From: Chris Robinson Date: Mon, 4 Nov 2013 10:51:22 -0800 Subject: Use a unique backend type for loopback --- Alc/ALc.c | 2 +- Alc/backends/base.h | 3 ++- Alc/backends/loopback.c | 59 ++++++++++++++++++++++++------------------------- 3 files changed, 32 insertions(+), 32 deletions(-) (limited to 'Alc/backends/loopback.c') diff --git a/Alc/ALc.c b/Alc/ALc.c index 6ee2b997..95b262b6 100644 --- a/Alc/ALc.c +++ b/Alc/ALc.c @@ -3318,7 +3318,7 @@ ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(const ALCchar *deviceN InitUIntMap(&device->FilterMap, ~0); factory = ALCloopbackFactory_getFactory(); - device->Backend = V(factory,createBackend)(device, ALCbackend_Playback); + device->Backend = V(factory,createBackend)(device, ALCbackend_Loopback); if(!device->Backend) { al_free(device); diff --git a/Alc/backends/base.h b/Alc/backends/base.h index 607ca6e8..1bbc1fb0 100644 --- a/Alc/backends/base.h +++ b/Alc/backends/base.h @@ -82,7 +82,8 @@ DECLARE_ALCBACKEND_VTABLE(T) = { \ typedef enum ALCbackend_Type { ALCbackend_Playback, - ALCbackend_Capture + ALCbackend_Capture, + ALCbackend_Loopback } ALCbackend_Type; diff --git a/Alc/backends/loopback.c b/Alc/backends/loopback.c index e400fcf2..cd5b1a1e 100644 --- a/Alc/backends/loopback.c +++ b/Alc/backends/loopback.c @@ -31,12 +31,21 @@ typedef struct ALCloopback { DERIVE_FROM_TYPE(ALCbackend); } ALCloopback; -DECLARE_ALCBACKEND_VTABLE(ALCloopback); +static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device); static DECLARE_FORWARD(ALCloopback, ALCbackend, void, Destruct) +static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name); +static void ALCloopback_close(ALCloopback *self); +static ALCboolean ALCloopback_reset(ALCloopback *self); +static ALCboolean ALCloopback_start(ALCloopback *self); +static void ALCloopback_stop(ALCloopback *self); +static DECLARE_FORWARD2(ALCloopback, ALCbackend, ALCenum, captureSamples, void*, ALCuint) +static DECLARE_FORWARD(ALCloopback, ALCbackend, ALCuint, availableSamples) static DECLARE_FORWARD(ALCloopback, ALCbackend, ALint64, getLatency) static DECLARE_FORWARD(ALCloopback, ALCbackend, void, lock) static DECLARE_FORWARD(ALCloopback, ALCbackend, void, unlock) +static void ALCloopback_Delete(ALCloopback *self); +DEFINE_ALCBACKEND_VTABLE(ALCloopback); static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device) @@ -73,55 +82,54 @@ static void ALCloopback_stop(ALCloopback* UNUSED(self)) { } -ALCenum ALCloopback_captureSamples(ALCloopback* UNUSED(self), void* UNUSED(buffer), ALCuint UNUSED(samples)) -{ - return ALC_INVALID_VALUE; -} - -ALCuint ALCloopback_availableSamples(ALCloopback* UNUSED(self)) -{ - return 0; -} - static void ALCloopback_Delete(ALCloopback *self) { free(self); } -DEFINE_ALCBACKEND_VTABLE(ALCloopback); - typedef struct ALCloopbackFactory { DERIVE_FROM_TYPE(ALCbackendFactory); } ALCloopbackFactory; #define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCloopbackFactory, ALCbackendFactory) } } -ALCboolean ALCloopbackFactory_init(ALCloopbackFactory* UNUSED(self)) +ALCbackendFactory *ALCloopbackFactory_getFactory(void); +static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory *self); +static DECLARE_FORWARD(ALCloopbackFactory, ALCbackendFactory, void, deinit) +static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory *self, ALCbackend_Type type); +static void ALCloopbackFactory_probe(ALCloopbackFactory *self, enum DevProbe type); +static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory *self, ALCdevice *device, ALCbackend_Type type); +DEFINE_ALCBACKENDFACTORY_VTABLE(ALCloopbackFactory); + + +ALCbackendFactory *ALCloopbackFactory_getFactory(void) { - return ALC_TRUE; + static ALCloopbackFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER; + return STATIC_CAST(ALCbackendFactory, &factory); } -void ALCloopbackFactory_deinit(ALCloopbackFactory* UNUSED(self)) +static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory* UNUSED(self)) { + return ALC_TRUE; } -ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory* UNUSED(self), ALCbackend_Type type) +static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory* UNUSED(self), ALCbackend_Type type) { - if(type == ALCbackend_Playback) + if(type == ALCbackend_Loopback) return ALC_TRUE; return ALC_FALSE; } -void ALCloopbackFactory_probe(ALCloopbackFactory* UNUSED(self), enum DevProbe UNUSED(type)) +static void ALCloopbackFactory_probe(ALCloopbackFactory* UNUSED(self), enum DevProbe UNUSED(type)) { } -ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type) +static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type) { ALCloopback *backend; - assert(type == ALCbackend_Playback); + assert(type == ALCbackend_Loopback); backend = calloc(1, sizeof(*backend)); if(!backend) return NULL; @@ -130,12 +138,3 @@ ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), A return STATIC_CAST(ALCbackend, backend); } - -DEFINE_ALCBACKENDFACTORY_VTABLE(ALCloopbackFactory); - - -ALCbackendFactory *ALCloopbackFactory_getFactory(void) -{ - static ALCloopbackFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER; - return STATIC_CAST(ALCbackendFactory, &factory); -} -- cgit v1.2.3