common/JackGlobalsServer.cpp

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program 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
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifdef WIN32
  21 #pragma warning (disable : 4786)
  22 #endif
  23
  24 #include "JackGlobals.h"
  25
  26 // OSX
  27 #if defined(__APPLE__)
  28 #include "JackCoreAudioDriver.h"
  29 #include "JackMachServerNotifyChannel.h"
  30 #include "JackMachNotifyChannel.h"
  31 #include "JackMachServerChannel.h"
  32 #include "JackMachClientChannel.h"
  33 #include "JackMachThread.h"
  34 #include "JackMachSemaphore.h"
  35 #include "JackProcessSync.h"
  36
  37 #include "JackSocketServerNotifyChannel.h"
  38 #include "JackSocketNotifyChannel.h"
  39 #include "JackSocketServerChannel.h"
  40 #include "JackSocketClientChannel.h"
  41 #include "JackPosixThread.h"
  42 #include "JackPosixSemaphore.h"
  43 #include "JackFifo.h"
  44 #endif
  45
  46 // WINDOWS
  47 #ifdef WIN32
  48 #include "JackWinProcessSync.h"
  49 #include "JackWinNamedPipeServerNotifyChannel.h"
  50 #include "JackWinNamedPipeNotifyChannel.h"
  51 #include "JackWinNamedPipeServerChannel.h"
  52 #include "JackWinNamedPipeClientChannel.h"
  53 #include "JackWinEvent.h"
  54 #include "JackWinThread.h"
  55 #endif
  56
  57 // LINUX
  58 #ifdef __linux__
  59 #include "JackAlsaDriver.h"
  60 #include "JackProcessSync.h"
  61 #include "JackSocketServerNotifyChannel.h"
  62 #include "JackSocketNotifyChannel.h"
  63 #include "JackSocketServerChannel.h"
  64 #include "JackSocketClientChannel.h"
  65 #include "JackPosixThread.h"
  66 #include "JackPosixSemaphore.h"
  67 #include "JackFifo.h"
  68 #endif
  69
  70 // COMMON
  71 #include "JackDummyDriver.h"
  72 #include "JackAudioDriver.h"
  73
  74
  75 using namespace std;
  76
  77 namespace Jack
  78 {
  79
  80 #ifdef WIN32
  81 JackSynchro* JackFactoryWindowsServer::MakeSynchro()
  82 {
  83     return new JackWinEvent();
  84 }
  85
  86 JackServerNotifyChannelInterface* JackFactoryWindowsServer::MakeServerNotifyChannel()
  87 {
  88     return new JackWinNamedPipeServerNotifyChannel();
  89 }
  90
  91 JackClientChannelInterface* JackFactoryWindowsServer::MakeClientChannel()
  92 {
  93     return NULL;
  94 } // Not used
  95
  96 JackNotifyChannelInterface* JackFactoryWindowsServer::MakeNotifyChannel()
  97 {
  98     return new JackWinNamedPipeNotifyChannel();
  99 }
 100
 101 JackServerChannelInterface* JackFactoryWindowsServer::MakeServerChannel()
 102 {
 103     return new JackWinNamedPipeServerChannel();
 104 }
 105
 106 JackSyncInterface* JackFactoryWindowsServer::MakeInterProcessSync()
 107 {
 108     return new JackWinProcessSync();
 109 }
 110
 111 JackThread* JackFactoryWindowsServer::MakeThread(JackRunnableInterface* runnable)
 112 {
 113     return new JackWinThread(runnable);
 114 }
 115 #endif
 116
 117 #ifdef __linux__
 118
 119 #if defined(SOCKET_RPC_POSIX_SEMA)
 120 JackSynchro* JackFactoryLinuxServer::MakeSynchro()
 121 {
 122     return new JackPosixSemaphore();
 123 }
 124
 125 JackServerNotifyChannelInterface* JackFactoryLinuxServer::MakeServerNotifyChannel()
 126 {
 127     return new JackSocketServerNotifyChannel();
 128 }
 129
 130 JackClientChannelInterface* JackFactoryLinuxServer::MakeClientChannel()
 131 {
 132     return NULL;
 133 } // Not used
 134
 135 JackNotifyChannelInterface* JackFactoryLinuxServer::MakeNotifyChannel()
 136 {
 137     return new JackSocketNotifyChannel();
 138 }
 139
 140 JackServerChannelInterface* JackFactoryLinuxServer::MakeServerChannel()
 141 {
 142     return new JackSocketServerChannel();
 143 }
 144
 145 JackSyncInterface* JackFactoryLinuxServer::MakeInterProcessSync()
 146 {
 147     return new JackProcessSync();
 148 }
 149
 150 JackThread* JackFactoryLinuxServer::MakeThread(JackRunnableInterface* runnable)
 151 {
 152     return new JackPosixThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 153 }
 154 #endif
 155
 156 #if defined(SOCKET_RPC_FIFO_SEMA)
 157 JackSynchro* JackFactoryLinuxServer::MakeSynchro()
 158 {
 159     return new JackFifo();
 160 }
 161
 162 JackServerNotifyChannelInterface* JackFactoryLinuxServer::MakeServerNotifyChannel()
 163 {
 164     return new JackSocketServerNotifyChannel();
 165 }
 166
 167 JackClientChannelInterface* JackFactoryLinuxServer::MakeClientChannel()
 168 {
 169     return NULL;
 170 }
 171 // Not used
 172 JackNotifyChannelInterface* JackFactoryLinuxServer::MakeNotifyChannel()
 173 {
 174     return new JackSocketNotifyChannel();
 175 }
 176
 177 JackServerChannelInterface* JackFactoryLinuxServer::MakeServerChannel()
 178 {
 179     return new JackSocketServerChannel();
 180 }
 181
 182 JackSyncInterface* JackFactoryLinuxServer::MakeInterProcessSync()
 183 {
 184     return new JackProcessSync();
 185 }
 186
 187 JackThread* JackFactoryLinuxServer::MakeThread(JackRunnableInterface* runnable)
 188 {
 189     return new JackPosixThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 190 }
 191 #endif
 192
 193 #if defined(SOCKET_RPC_FIFO_SEMA_DUMMY)
 194 JackSynchro* JackFactoryLinuxServer::MakeSynchro()
 195 {
 196     return new JackFifo();
 197 }
 198
 199 JackServerNotifyChannelInterface* JackFactoryLinuxServer::MakeServerNotifyChannel()
 200 {
 201     return new JackSocketServerNotifyChannel();
 202 }
 203
 204 JackClientChannelInterface* JackFactoryLinuxServer::MakeClientChannel()
 205 {
 206     return NULL;
 207 }
 208 // Not used
 209 JackNotifyChannelInterface* JackFactoryLinuxServer::MakeNotifyChannel()
 210 {
 211     return new JackSocketNotifyChannel();
 212 }
 213
 214 JackServerChannelInterface* JackFactoryLinuxServer::MakeServerChannel()
 215 {
 216     return new JackSocketServerChannel();
 217 }
 218
 219 JackSyncInterface* JackFactoryLinuxServer::MakeInterProcessSync()
 220 {
 221     return new JackProcessSync();
 222 }
 223
 224 JackThread* JackFactoryLinuxServer::MakeThread(JackRunnableInterface* runnable)
 225 {
 226     return new JackPosixThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 227 }
 228 #endif
 229
 230 #endif
 231
 232 #if defined(__APPLE__)
 233
 234 #if defined(MACH_RPC_MACH_SEMA)
 235 // Mach RPC + Mach Semaphore
 236 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 237 {
 238     return new JackMachSemaphore();
 239 }
 240
 241 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 242 {
 243     return new JackMachServerNotifyChannel();
 244 }
 245
 246 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 247 {
 248     return NULL;
 249 } // Not used
 250
 251 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 252 {
 253     return new JackMachNotifyChannel();
 254 }
 255
 256 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 257 {
 258     return new JackMachServerChannel();
 259 }
 260
 261 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 262 {
 263     return new JackProcessSync();
 264 }
 265
 266 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 267 {
 268     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 269 }
 270 #endif
 271
 272 #if defined(SOCKET_RPC_POSIX_SEMA)
 273 // Socket RPC + Posix Semaphore
 274 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 275 {
 276     return new JackPosixSemaphore();
 277 }
 278
 279 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 280 {
 281     return new JackSocketServerNotifyChannel();
 282 }
 283
 284 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 285 {
 286     return NULL;
 287 }
 288 // Not used
 289 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 290 {
 291     return new JackSocketNotifyChannel();
 292 }
 293
 294 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 295 {
 296     return new JackSocketServerChannel();
 297 }
 298
 299 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 300 {
 301     return new JackProcessSync();
 302 }
 303
 304 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 305 {
 306     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 307 }
 308 #endif
 309
 310 #if defined(SOCKET_RPC_FIFO_SEMA)
 311 // Socket RPC + Fifo Semaphore
 312 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 313 {
 314     return new JackFifo();
 315 }
 316
 317 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 318 {
 319     return new JackSocketServerNotifyChannel();
 320 }
 321
 322 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 323 {
 324     return NULL;
 325 }
 326 // Not used
 327 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 328 {
 329     return new JackSocketNotifyChannel();
 330 }
 331
 332 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 333 {
 334     return new JackSocketServerChannel();
 335 }
 336
 337 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 338 {
 339     return new JackProcessSync();
 340 }
 341
 342 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 343 {
 344     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 345 }
 346 #endif
 347
 348 #if defined(MACH_RPC_FIFO_SEMA)
 349 // Mach RPC + Fifo Semaphore
 350 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 351 {
 352     return new JackFifo();
 353 }
 354
 355 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 356 {
 357     return new JackMachServerNotifyChannel();
 358 }
 359
 360 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 361 {
 362     return NULL;
 363 }
 364 // Not used
 365 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 366 {
 367     return new JackMachNotifyChannel();
 368 }
 369
 370 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 371 {
 372     return new JackMachServerChannel();
 373 }
 374
 375 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 376 {
 377     return new JackProcessSync();
 378 }
 379
 380 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 381 {
 382     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 383 }
 384 #endif
 385
 386 #if defined(MACH_RPC_POSIX_SEMA)
 387 // Mach RPC + Posix Semaphore
 388 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 389 {
 390     return new JackPosixSemaphore();
 391 }
 392
 393 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 394 {
 395     return new JackMachServerNotifyChannel();
 396 }
 397
 398 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 399 {
 400     return NULL;
 401 }
 402 // Not used
 403 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 404 {
 405     return new JackMachNotifyChannel();
 406 }
 407
 408 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 409 {
 410     return new JackMachServerChannel();
 411 }
 412
 413 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 414 {
 415     return new JackProcessSync();
 416 }
 417
 418 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 419 {
 420     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 421 }
 422 #endif
 423
 424 #if defined(SOCKET_RPC_MACH_SEMA)
 425 // Socket RPC + Mac Semaphore
 426 JackSynchro* JackFactoryOSXServer::MakeSynchro()
 427 {
 428     return new JackMachSemaphore();
 429 }
 430
 431 JackServerNotifyChannelInterface* JackFactoryOSXServer::MakeServerNotifyChannel()
 432 {
 433     return new JackSocketServerNotifyChannel();
 434 }
 435
 436 JackClientChannelInterface* JackFactoryOSXServer::MakeClientChannel()
 437 {
 438     return NULL;
 439 }
 440 // Not used
 441 JackNotifyChannelInterface* JackFactoryOSXServer::MakeNotifyChannel()
 442 {
 443     return new JackSocketNotifyChannel();
 444 }
 445
 446 JackServerChannelInterface* JackFactoryOSXServer::MakeServerChannel()
 447 {
 448     return new JackSocketServerChannel();
 449 }
 450
 451 JackSyncInterface* JackFactoryOSXServer::MakeInterProcessSync()
 452 {
 453     return new JackProcessSync();
 454 }
 455
 456 JackThread* JackFactoryOSXServer::MakeThread(JackRunnableInterface* runnable)
 457 {
 458     return new JackMachThread(runnable, PTHREAD_CANCEL_ASYNCHRONOUS);
 459 }
 460 #endif
 461
 462 #endif
 463
 464 } // end of namespace