Alc/backends/base.h

   1 #ifndef AL_BACKENDS_BASE_H
   2 #define AL_BACKENDS_BASE_H
   3
   4 #include "alMain.h"
   5 #include "threads.h"
   6
   7
   8 #ifdef __cplusplus
   9 extern "C" {
  10 #endif
  11
  12 typedef struct ClockLatency {
  13     ALint64 ClockTime;
  14     ALint64 Latency;
  15 } ClockLatency;
  16
  17 /* Helper to get the current clock time from the device's ClockBase, and
  18  * SamplesDone converted from the sample rate.
  19  */
  20 inline ALuint64 GetDeviceClockTime(ALCdevice *device)
  21 {
  22     return device->ClockBase + (device->SamplesDone * DEVICE_CLOCK_RES /
  23                                 device->Frequency);
  24 }
  25
  26
  27 struct ALCbackendVtable;
  28
  29 typedef struct ALCbackend {
  30     const struct ALCbackendVtable *vtbl;
  31
  32     ALCdevice *mDevice;
  33
  34     almtx_t mMutex;
  35 } ALCbackend;
  36
  37 void ALCbackend_Construct(ALCbackend *self, ALCdevice *device);
  38 void ALCbackend_Destruct(ALCbackend *self);
  39 ALCboolean ALCbackend_reset(ALCbackend *self);
  40 ALCenum ALCbackend_captureSamples(ALCbackend *self, void *buffer, ALCuint samples);
  41 ALCuint ALCbackend_availableSamples(ALCbackend *self);
  42 ClockLatency ALCbackend_getClockLatency(ALCbackend *self);
  43 void ALCbackend_lock(ALCbackend *self);
  44 void ALCbackend_unlock(ALCbackend *self);
  45
  46 struct ALCbackendVtable {
  47     void (*const Destruct)(ALCbackend*);
  48
  49     ALCenum (*const open)(ALCbackend*, const ALCchar*);
  50
  51     ALCboolean (*const reset)(ALCbackend*);
  52     ALCboolean (*const start)(ALCbackend*);
  53     void (*const stop)(ALCbackend*);
  54
  55     ALCenum (*const captureSamples)(ALCbackend*, void*, ALCuint);
  56     ALCuint (*const availableSamples)(ALCbackend*);
  57
  58     ClockLatency (*const getClockLatency)(ALCbackend*);
  59
  60     void (*const lock)(ALCbackend*);
  61     void (*const unlock)(ALCbackend*);
  62
  63     void (*const Delete)(void*);
  64 };
  65
  66 #define DEFINE_ALCBACKEND_VTABLE(T)                                           \
  67 DECLARE_THUNK(T, ALCbackend, void, Destruct)                                  \
  68 DECLARE_THUNK1(T, ALCbackend, ALCenum, open, const ALCchar*)                  \
  69 DECLARE_THUNK(T, ALCbackend, ALCboolean, reset)                               \
  70 DECLARE_THUNK(T, ALCbackend, ALCboolean, start)                               \
  71 DECLARE_THUNK(T, ALCbackend, void, stop)                                      \
  72 DECLARE_THUNK2(T, ALCbackend, ALCenum, captureSamples, void*, ALCuint)        \
  73 DECLARE_THUNK(T, ALCbackend, ALCuint, availableSamples)                       \
  74 DECLARE_THUNK(T, ALCbackend, ClockLatency, getClockLatency)                   \
  75 DECLARE_THUNK(T, ALCbackend, void, lock)                                      \
  76 DECLARE_THUNK(T, ALCbackend, void, unlock)                                    \
  77 static void T##_ALCbackend_Delete(void *ptr)                                  \
  78 { T##_Delete(STATIC_UPCAST(T, ALCbackend, (ALCbackend*)ptr)); }               \
  79                                                                               \
  80 static const struct ALCbackendVtable T##_ALCbackend_vtable = {                \
  81     T##_ALCbackend_Destruct,                                                  \
  82                                                                               \
  83     T##_ALCbackend_open,                                                      \
  84     T##_ALCbackend_reset,                                                     \
  85     T##_ALCbackend_start,                                                     \
  86     T##_ALCbackend_stop,                                                      \
  87     T##_ALCbackend_captureSamples,                                            \
  88     T##_ALCbackend_availableSamples,                                          \
  89     T##_ALCbackend_getClockLatency,                                           \
  90     T##_ALCbackend_lock,                                                      \
  91     T##_ALCbackend_unlock,                                                    \
  92                                                                               \
  93     T##_ALCbackend_Delete,                                                    \
  94 }
  95
  96
  97 typedef enum ALCbackend_Type {
  98     ALCbackend_Playback,
  99     ALCbackend_Capture,
 100     ALCbackend_Loopback
 101 } ALCbackend_Type;
 102
 103
 104 struct ALCbackendFactoryVtable;
 105
 106 typedef struct ALCbackendFactory {
 107     const struct ALCbackendFactoryVtable *vtbl;
 108 } ALCbackendFactory;
 109
 110 void ALCbackendFactory_deinit(ALCbackendFactory *self);
 111
 112 struct ALCbackendFactoryVtable {
 113     ALCboolean (*const init)(ALCbackendFactory *self);
 114     void (*const deinit)(ALCbackendFactory *self);
 115
 116     ALCboolean (*const querySupport)(ALCbackendFactory *self, ALCbackend_Type type);
 117
 118     void (*const probe)(ALCbackendFactory *self, enum DevProbe type);
 119
 120     ALCbackend* (*const createBackend)(ALCbackendFactory *self, ALCdevice *device, ALCbackend_Type type);
 121 };
 122
 123 #define DEFINE_ALCBACKENDFACTORY_VTABLE(T)                                    \
 124 DECLARE_THUNK(T, ALCbackendFactory, ALCboolean, init)                         \
 125 DECLARE_THUNK(T, ALCbackendFactory, void, deinit)                             \
 126 DECLARE_THUNK1(T, ALCbackendFactory, ALCboolean, querySupport, ALCbackend_Type) \
 127 DECLARE_THUNK1(T, ALCbackendFactory, void, probe, enum DevProbe)              \
 128 DECLARE_THUNK2(T, ALCbackendFactory, ALCbackend*, createBackend, ALCdevice*, ALCbackend_Type) \
 129                                                                               \
 130 static const struct ALCbackendFactoryVtable T##_ALCbackendFactory_vtable = {  \
 131     T##_ALCbackendFactory_init,                                               \
 132     T##_ALCbackendFactory_deinit,                                             \
 133     T##_ALCbackendFactory_querySupport,                                       \
 134     T##_ALCbackendFactory_probe,                                              \
 135     T##_ALCbackendFactory_createBackend,                                      \
 136 }
 137
 138
 139 ALCbackendFactory *ALCpulseBackendFactory_getFactory(void);
 140 ALCbackendFactory *ALCalsaBackendFactory_getFactory(void);
 141 ALCbackendFactory *ALCcoreAudioBackendFactory_getFactory(void);
 142 ALCbackendFactory *ALCossBackendFactory_getFactory(void);
 143 ALCbackendFactory *ALCjackBackendFactory_getFactory(void);
 144 ALCbackendFactory *ALCsolarisBackendFactory_getFactory(void);
 145 ALCbackendFactory *ALCsndioBackendFactory_getFactory(void);
 146 ALCbackendFactory *ALCqsaBackendFactory_getFactory(void);
 147 ALCbackendFactory *ALCwasapiBackendFactory_getFactory(void);
 148 ALCbackendFactory *ALCdsoundBackendFactory_getFactory(void);
 149 ALCbackendFactory *ALCwinmmBackendFactory_getFactory(void);
 150 ALCbackendFactory *ALCportBackendFactory_getFactory(void);
 151 ALCbackendFactory *ALCopenslBackendFactory_getFactory(void);
 152 ALCbackendFactory *ALCnullBackendFactory_getFactory(void);
 153 ALCbackendFactory *ALCwaveBackendFactory_getFactory(void);
 154 ALCbackendFactory *ALCsdl2BackendFactory_getFactory(void);
 155 ALCbackendFactory *ALCloopbackFactory_getFactory(void);
 156
 157
 158 inline void ALCdevice_Lock(ALCdevice *device)
 159 { V0(device->Backend,lock)(); }
 160
 161 inline void ALCdevice_Unlock(ALCdevice *device)
 162 { V0(device->Backend,unlock)(); }
 163
 164 #ifdef __cplusplus
 165 } /* extern "C" */
 166 #endif
 167
 168 #endif /* AL_BACKENDS_BASE_H */