Alc/backends/jack.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26
  27 #include "alMain.h"
  28 #include "alu.h"
  29 #include "threads.h"
  30 #include "compat.h"
  31
  32 #include "backends/base.h"
  33
  34 #include <jack/jack.h>
  35 #include <jack/ringbuffer.h>
  36
  37
  38 static const ALCchar jackDevice[] = "JACK Default";
  39
  40
  41 #ifdef HAVE_DYNLOAD
  42 #define JACK_FUNCS(MAGIC)         \
  43     MAGIC(jack_client_open);      \
  44     MAGIC(jack_client_close);     \
  45     MAGIC(jack_client_name_size); \
  46     MAGIC(jack_get_client_name);
  47
  48 static void *jack_handle;
  49 #define MAKE_FUNC(f) static __typeof(f) * p##f
  50 JACK_FUNCS(MAKE_FUNC);
  51 #undef MAKE_FUNC
  52
  53 #define jack_client_open pjack_client_open
  54 #define jack_client_close pjack_client_close
  55 #define jack_client_name_size pjack_client_name_size
  56 #define jack_get_client_name pjack_get_client_name
  57 #endif
  58
  59
  60 static ALCboolean jack_load(void)
  61 {
  62     ALCboolean error = ALC_FALSE;
  63
  64 #ifdef HAVE_DYNLOAD
  65     if(!jack_handle)
  66     {
  67         jack_handle = LoadLib("libjack.so.0");
  68         if(!jack_handle)
  69             return ALC_FALSE;
  70
  71         error = ALC_FALSE;
  72 #define LOAD_FUNC(f) do {                                                     \
  73     p##f = GetSymbol(jack_handle, #f);                                        \
  74     if(p##f == NULL) {                                                        \
  75         error = ALC_TRUE;                                                     \
  76     }                                                                         \
  77 } while(0)
  78         JACK_FUNCS(LOAD_FUNC);
  79 #undef LOAD_FUNC
  80
  81         if(error)
  82         {
  83             CloseLib(jack_handle);
  84             jack_handle = NULL;
  85             return ALC_FALSE;
  86         }
  87     }
  88 #endif
  89
  90     return !error;
  91 }
  92
  93
  94 typedef struct ALCjackPlayback {
  95     DERIVE_FROM_TYPE(ALCbackend);
  96
  97     jack_client_t *Client;
  98
  99     volatile int killNow;
 100     althrd_t thread;
 101 } ALCjackPlayback;
 102
 103 static void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device);
 104 static void ALCjackPlayback_Destruct(ALCjackPlayback *self);
 105 static ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name);
 106 static void ALCjackPlayback_close(ALCjackPlayback *self);
 107 static ALCboolean ALCjackPlayback_reset(ALCjackPlayback *self);
 108 static ALCboolean ALCjackPlayback_start(ALCjackPlayback *self);
 109 static void ALCjackPlayback_stop(ALCjackPlayback *self);
 110 static DECLARE_FORWARD2(ALCjackPlayback, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
 111 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, ALCuint, availableSamples)
 112 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, ALint64, getLatency)
 113 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, lock)
 114 static DECLARE_FORWARD(ALCjackPlayback, ALCbackend, void, unlock)
 115 DECLARE_DEFAULT_ALLOCATORS(ALCjackPlayback)
 116
 117 DEFINE_ALCBACKEND_VTABLE(ALCjackPlayback);
 118
 119
 120 static void ALCjackPlayback_Construct(ALCjackPlayback *self, ALCdevice *device)
 121 {
 122     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
 123     SET_VTABLE2(ALCjackPlayback, ALCbackend, self);
 124
 125     self->Client = NULL;
 126     self->killNow = 1;
 127 }
 128
 129 static void ALCjackPlayback_Destruct(ALCjackPlayback *self)
 130 {
 131     if(self->Client)
 132         jack_client_close(self->Client);
 133     self->Client = NULL;
 134
 135     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
 136 }
 137
 138
 139 static ALCenum ALCjackPlayback_open(ALCjackPlayback *self, const ALCchar *name)
 140 {
 141     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 142
 143     if(!name)
 144         name = jackDevice;
 145     else if(strcmp(name, jackDevice) != 0)
 146         return ALC_INVALID_VALUE;
 147
 148
 149     al_string_copy_cstr(&device->DeviceName, name);
 150
 151     return ALC_INVALID_VALUE;
 152 }
 153
 154 static void ALCjackPlayback_close(ALCjackPlayback *UNUSED(self))
 155 {
 156 }
 157
 158 static ALCboolean ALCjackPlayback_reset(ALCjackPlayback *UNUSED(self))
 159 {
 160     //jack_set_process_callback (client, process, &data);
 161     return ALC_FALSE;
 162 }
 163
 164 static ALCboolean ALCjackPlayback_start(ALCjackPlayback *UNUSED(self))
 165 {
 166     return ALC_FALSE;
 167 }
 168
 169 static void ALCjackPlayback_stop(ALCjackPlayback *self)
 170 {
 171     int res;
 172
 173     if(self->killNow)
 174         return;
 175
 176     self->killNow = 1;
 177     althrd_join(self->thread, &res);
 178 }
 179
 180
 181 typedef struct ALCjackBackendFactory {
 182     DERIVE_FROM_TYPE(ALCbackendFactory);
 183 } ALCjackBackendFactory;
 184 #define ALCJACKBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCjackBackendFactory, ALCbackendFactory) } }
 185
 186 static ALCboolean ALCjackBackendFactory_init(ALCjackBackendFactory* UNUSED(self))
 187 {
 188     jack_client_t *client;
 189     jack_status_t status;
 190
 191     if(!jack_load())
 192         return ALC_FALSE;
 193
 194     client = jack_client_open("alsoft", 0, &status, NULL);
 195     if(client == NULL)
 196     {
 197         WARN("jack_client_open() failed, 0x%02x\n", status);
 198         if((status&JackServerFailed))
 199             ERR("Unable to connect to JACK server\n");
 200         return ALC_FALSE;
 201     }
 202
 203     jack_client_close(client);
 204     return ALC_TRUE;
 205 }
 206
 207 static void ALCjackBackendFactory_deinit(ALCjackBackendFactory* UNUSED(self))
 208 {
 209 #ifdef HAVE_DYNLOAD
 210     if(jack_handle)
 211         CloseLib(jack_handle);
 212     jack_handle = NULL;
 213 #endif
 214 }
 215
 216 static ALCboolean ALCjackBackendFactory_querySupport(ALCjackBackendFactory* UNUSED(self), ALCbackend_Type type)
 217 {
 218     if(type == ALCbackend_Playback)
 219         return ALC_TRUE;
 220     return ALC_FALSE;
 221 }
 222
 223 static void ALCjackBackendFactory_probe(ALCjackBackendFactory* UNUSED(self), enum DevProbe type)
 224 {
 225     switch(type)
 226     {
 227         case ALL_DEVICE_PROBE:
 228             AppendAllDevicesList(jackDevice);
 229             break;
 230
 231         case CAPTURE_DEVICE_PROBE:
 232             break;
 233     }
 234 }
 235
 236 static ALCbackend* ALCjackBackendFactory_createBackend(ALCjackBackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
 237 {
 238     if(type == ALCbackend_Playback)
 239     {
 240         ALCjackPlayback *backend;
 241
 242         backend = ALCjackPlayback_New(sizeof(*backend));
 243         if(!backend) return NULL;
 244         memset(backend, 0, sizeof(*backend));
 245
 246         ALCjackPlayback_Construct(backend, device);
 247
 248         return STATIC_CAST(ALCbackend, backend);
 249     }
 250
 251     return NULL;
 252 }
 253
 254 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCjackBackendFactory);
 255
 256
 257 ALCbackendFactory *ALCjackBackendFactory_getFactory(void)
 258 {
 259     static ALCjackBackendFactory factory = ALCJACKBACKENDFACTORY_INITIALIZER;
 260     return STATIC_CAST(ALCbackendFactory, &factory);
 261 }