Alc/backends/loopback.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2011 by Chris Robinson
   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
  25 #include "alMain.h"
  26 #include "alu.h"
  27
  28 #include "backends/base.h"
  29
  30
  31 typedef struct ALCloopback {
  32     DERIVE_FROM_TYPE(ALCbackend);
  33 } ALCloopback;
  34
  35 static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device);
  36 static DECLARE_FORWARD(ALCloopback, ALCbackend, void, Destruct)
  37 static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name);
  38 static ALCboolean ALCloopback_reset(ALCloopback *self);
  39 static ALCboolean ALCloopback_start(ALCloopback *self);
  40 static void ALCloopback_stop(ALCloopback *self);
  41 static DECLARE_FORWARD2(ALCloopback, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
  42 static DECLARE_FORWARD(ALCloopback, ALCbackend, ALCuint, availableSamples)
  43 static DECLARE_FORWARD(ALCloopback, ALCbackend, ClockLatency, getClockLatency)
  44 static DECLARE_FORWARD(ALCloopback, ALCbackend, void, lock)
  45 static DECLARE_FORWARD(ALCloopback, ALCbackend, void, unlock)
  46 DECLARE_DEFAULT_ALLOCATORS(ALCloopback)
  47 DEFINE_ALCBACKEND_VTABLE(ALCloopback);
  48
  49
  50 static void ALCloopback_Construct(ALCloopback *self, ALCdevice *device)
  51 {
  52     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
  53     SET_VTABLE2(ALCloopback, ALCbackend, self);
  54 }
  55
  56
  57 static ALCenum ALCloopback_open(ALCloopback *self, const ALCchar *name)
  58 {
  59     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
  60
  61     alstr_copy_cstr(&device->DeviceName, name);
  62     return ALC_NO_ERROR;
  63 }
  64
  65 static ALCboolean ALCloopback_reset(ALCloopback *self)
  66 {
  67     SetDefaultWFXChannelOrder(STATIC_CAST(ALCbackend, self)->mDevice);
  68     return ALC_TRUE;
  69 }
  70
  71 static ALCboolean ALCloopback_start(ALCloopback* UNUSED(self))
  72 {
  73     return ALC_TRUE;
  74 }
  75
  76 static void ALCloopback_stop(ALCloopback* UNUSED(self))
  77 {
  78 }
  79
  80
  81 typedef struct ALCloopbackFactory {
  82     DERIVE_FROM_TYPE(ALCbackendFactory);
  83 } ALCloopbackFactory;
  84 #define ALCNULLBACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCloopbackFactory, ALCbackendFactory) } }
  85
  86 ALCbackendFactory *ALCloopbackFactory_getFactory(void);
  87 static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory *self);
  88 static DECLARE_FORWARD(ALCloopbackFactory, ALCbackendFactory, void, deinit)
  89 static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory *self, ALCbackend_Type type);
  90 static void ALCloopbackFactory_probe(ALCloopbackFactory *self, enum DevProbe type);
  91 static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory *self, ALCdevice *device, ALCbackend_Type type);
  92 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCloopbackFactory);
  93
  94
  95 ALCbackendFactory *ALCloopbackFactory_getFactory(void)
  96 {
  97     static ALCloopbackFactory factory = ALCNULLBACKENDFACTORY_INITIALIZER;
  98     return STATIC_CAST(ALCbackendFactory, &factory);
  99 }
 100
 101 static ALCboolean ALCloopbackFactory_init(ALCloopbackFactory* UNUSED(self))
 102 {
 103     return ALC_TRUE;
 104 }
 105
 106 static ALCboolean ALCloopbackFactory_querySupport(ALCloopbackFactory* UNUSED(self), ALCbackend_Type type)
 107 {
 108     if(type == ALCbackend_Loopback)
 109         return ALC_TRUE;
 110     return ALC_FALSE;
 111 }
 112
 113 static void ALCloopbackFactory_probe(ALCloopbackFactory* UNUSED(self), enum DevProbe UNUSED(type))
 114 {
 115 }
 116
 117 static ALCbackend* ALCloopbackFactory_createBackend(ALCloopbackFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
 118 {
 119     if(type == ALCbackend_Loopback)
 120     {
 121         ALCloopback *backend;
 122         NEW_OBJ(backend, ALCloopback)(device);
 123         if(!backend) return NULL;
 124         return STATIC_CAST(ALCbackend, backend);
 125     }
 126
 127     return NULL;
 128 }