OpenAL goes to great lengths to support many different systems, all with different sound capabilities and interfaces. It accomplishes this difficult task by providing code for many different sound backends in pseudo-objects called Devices. There's a device for the Linux Open Sound System and the Advanced Linux Sound Architecture, there's one for Direct Sound on Windows, there's even one for Solaris. OpenAL solves the problem of platform independence by providing all these Devices.

Wrapper libraries such as LWJGL are free to examine the system on which they are running and then select an appropriate device for that system.

There are also a few "special" devices that don't interface with any particular system. These include the Null Device, which doesn't do anything, and the Wave Device, which writes whatever sound it receives to a file, if everything has been set up correctly when configuring OpenAL.

Actual mixing of the sound data happens in the Devices, and they are the only point in the sound rendering process where this data is available.

Therefore, in order to support multiple listeners, and get the sound data in a form that the AIs can use, it is necessary to create a new Device, which supports this features.

Adding a device to OpenAL is rather tricky – there are five separate files in the OpenAL source tree that must be modified to do so. I've documented this process here for anyone who is interested.

Onward to that actual Device!

again, my objectives are:

• Support Multiple Listeners from jMonkeyEngine3
• Get access to the rendered sound data for further processing from clojure.

#include "config.h"
#include <stdlib.h>
#include "alMain.h"
#include "AL/al.h"
#include "AL/alc.h"
#include "alSource.h"
#include <jni.h>

//////////////////// Summary

struct send_data;
struct context_data;

static void addContext(ALCdevice *, ALCcontext *);
static void syncContexts(ALCcontext *master, ALCcontext *slave);
static void syncSources(ALsource *master, ALsource *slave, 
                        ALCcontext *masterCtx, ALCcontext *slaveCtx);

static void syncSourcei(ALuint master, ALuint slave,
                        ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param);
static void syncSourcef(ALuint master, ALuint slave,
                        ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param);
static void syncSource3f(ALuint master, ALuint slave,
                        ALCcontext *masterCtx, ALCcontext *ctx2, ALenum param);

static void swapInContext(ALCdevice *, struct context_data *);
static void saveContext(ALCdevice *, struct context_data *);
static void limitContext(ALCdevice *, ALCcontext *);
static void unLimitContext(ALCdevice *);

static void init(ALCdevice *);
static void renderData(ALCdevice *, int samples);

#define UNUSED(x)  (void)(x)

The main idea behind the Send device is to take advantage of the fact that LWJGL only manages one context when using OpenAL. A context is like a container that holds samples and keeps track of where the listener is. In order to support multiple listeners, the Send device identifies the LWJGL context as the master context, and creates any number of slave contexts to represent additional listeners. Every time the device renders sound, it synchronizes every source from the master LWJGL context to the slave contexts. Then, it renders each context separately, using a different listener for each one. The rendered sound is made available via JNI to jMonkeyEngine.

To recap, the process is:

• Set the LWJGL context as "master" in the init() method.
• Create any number of additional contexts via addContext()
• At every call to renderData() sync the master context with the slave contexts with syncContexts()
• syncContexts() calls syncSources() to sync all the sources which are in the master context.
• limitContext() and unLimitContext() make it possible to render only one context at a time.

////////////////////  State

typedef struct context_data {
  ALfloat ClickRemoval[MAXCHANNELS];
  ALfloat PendingClicks[MAXCHANNELS];
  ALvoid *renderBuffer;
  ALCcontext *ctx;
} context_data;

typedef struct send_data {
  ALuint size;
  context_data **contexts;
  ALuint numContexts;
  ALuint maxContexts;
} send_data;

Switching between contexts is not the normal operation of a Device, and one of the problems with doing so is that a Device normally keeps around a few pieces of state such as the ClickRemoval array above which will become corrupted if the contexts are not done in parallel. The solution is to create a copy of this normally global device state for each context, and copy it back and forth into and out of the actual device state whenever a context is rendered.

////////////////////  Context Creation / Synchronization

#define _MAKE_SYNC(NAME, INIT_EXPR, GET_EXPR, SET_EXPR) \
  void NAME (ALuint sourceID1, ALuint sourceID2,        \
             ALCcontext *ctx1, ALCcontext *ctx2,        \
             ALenum param){                             \
    INIT_EXPR;                                          \
    ALCcontext *current = alcGetCurrentContext();       \
    alcMakeContextCurrent(ctx1);                        \
    GET_EXPR;                                           \
    alcMakeContextCurrent(ctx2);                        \
    SET_EXPR;                                           \
    alcMakeContextCurrent(current);                     \
  }
  
#define MAKE_SYNC(NAME, TYPE, GET, SET)                 \
  _MAKE_SYNC(NAME,                                      \
             TYPE value,                                \
             GET(sourceID1, param, &value),             \
             SET(sourceID2, param, value))
  
#define MAKE_SYNC3(NAME, TYPE, GET, SET)                                \
  _MAKE_SYNC(NAME,                                                      \
             TYPE value1; TYPE value2; TYPE value3;,                    \
             GET(sourceID1, param, &value1, &value2, &value3),          \
             SET(sourceID2, param,  value1,  value2,  value3))

MAKE_SYNC( syncSourcei,  ALint,   alGetSourcei,  alSourcei);
MAKE_SYNC( syncSourcef,  ALfloat, alGetSourcef,  alSourcef);
MAKE_SYNC3(syncSource3i, ALint,   alGetSource3i, alSource3i);
MAKE_SYNC3(syncSource3f, ALfloat, alGetSource3f, alSource3f);
  

Setting the state of an OpenAL source is done with the alSourcei, alSourcef, alSource3i, and alSource3f functions. In order to completely synchronize two sources, it is necessary to use all of them. These macros help to condense the otherwise repetitive synchronization code involving these similar low-level OpenAL functions.

void syncSources(ALsource *masterSource, ALsource *slaveSource, 
                 ALCcontext *masterCtx, ALCcontext *slaveCtx){
  ALuint master = masterSource->source;
  ALuint slave = slaveSource->source;
  ALCcontext *current = alcGetCurrentContext();

  syncSourcef(master,slave,masterCtx,slaveCtx,AL_PITCH);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_GAIN);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_MAX_DISTANCE);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_ROLLOFF_FACTOR);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_REFERENCE_DISTANCE);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_MIN_GAIN);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_MAX_GAIN);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_OUTER_GAIN);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_INNER_ANGLE);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_CONE_OUTER_ANGLE);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_SEC_OFFSET);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_SAMPLE_OFFSET);
  syncSourcef(master,slave,masterCtx,slaveCtx,AL_BYTE_OFFSET);
    
  syncSource3f(master,slave,masterCtx,slaveCtx,AL_POSITION);
  syncSource3f(master,slave,masterCtx,slaveCtx,AL_VELOCITY);
  syncSource3f(master,slave,masterCtx,slaveCtx,AL_DIRECTION);
  
  syncSourcei(master,slave,masterCtx,slaveCtx,AL_SOURCE_RELATIVE);
  syncSourcei(master,slave,masterCtx,slaveCtx,AL_LOOPING);

  alcMakeContextCurrent(masterCtx);
  ALint source_type;
  alGetSourcei(master, AL_SOURCE_TYPE, &source_type);

  // Only static sources are currently synchronized! 
  if (AL_STATIC == source_type){
    ALint master_buffer;
    ALint slave_buffer;
    alGetSourcei(master, AL_BUFFER, &master_buffer);
    alcMakeContextCurrent(slaveCtx);
    alGetSourcei(slave, AL_BUFFER, &slave_buffer);
    if (master_buffer != slave_buffer){
      alSourcei(slave, AL_BUFFER, master_buffer);
    }
  }
  
  // Synchronize the state of the two sources.
  alcMakeContextCurrent(masterCtx);
  ALint masterState;
  ALint slaveState;

  alGetSourcei(master, AL_SOURCE_STATE, &masterState);
  alcMakeContextCurrent(slaveCtx);
  alGetSourcei(slave, AL_SOURCE_STATE, &slaveState);

  if (masterState != slaveState){
    switch (masterState){
    case AL_INITIAL : alSourceRewind(slave); break;
    case AL_PLAYING : alSourcePlay(slave);   break;
    case AL_PAUSED  : alSourcePause(slave);  break;
    case AL_STOPPED : alSourceStop(slave);   break;
    }
  }
  // Restore whatever context was previously active.
  alcMakeContextCurrent(current);
}

This function is long because it has to exhaustively go through all the possible state that a source can have and make sure that it is the same between the master and slave sources. I'd like to take this moment to salute the OpenAL Reference Manual, which provides a very good description of OpenAL's internals.

void syncContexts(ALCcontext *master, ALCcontext *slave){
  /* If there aren't sufficient sources in slave to mirror 
     the sources in master, create them. */
  ALCcontext *current = alcGetCurrentContext();

  UIntMap *masterSourceMap = &(master->SourceMap);
  UIntMap *slaveSourceMap = &(slave->SourceMap);
  ALuint numMasterSources = masterSourceMap->size;
  ALuint numSlaveSources = slaveSourceMap->size;

  alcMakeContextCurrent(slave);
  if (numSlaveSources < numMasterSources){
    ALuint numMissingSources = numMasterSources - numSlaveSources;
    ALuint newSources[numMissingSources];
    alGenSources(numMissingSources, newSources);
  }

  /* Now, slave is guaranteed to have at least as many sources
     as master.  Sync each source from master to the corresponding
     source in slave. */
  int i;
  for(i = 0; i < masterSourceMap->size; i++){
    syncSources((ALsource*)masterSourceMap->array[i].value,
                (ALsource*)slaveSourceMap->array[i].value,
                master, slave);
  }
  alcMakeContextCurrent(current);
}

Most of the hard work in Context Synchronization is done in syncSources(). The only thing that syncContexts() has to worry about is automatically creating new sources whenever a slave context does not have the same number of sources as the master context.

static void addContext(ALCdevice *Device, ALCcontext *context){
  send_data *data = (send_data*)Device->ExtraData;
  // expand array if necessary
  if (data->numContexts >= data->maxContexts){
    ALuint newMaxContexts = data->maxContexts*2 + 1;
    data->contexts = realloc(data->contexts, newMaxContexts*sizeof(context_data));
    data->maxContexts = newMaxContexts;
  }
  // create context_data and add it to the main array
  context_data *ctxData;
  ctxData = (context_data*)calloc(1, sizeof(*ctxData));
  ctxData->renderBuffer = 
    malloc(BytesFromDevFmt(Device->FmtType) * 
           Device->NumChan * Device->UpdateSize);
  ctxData->ctx = context;

  data->contexts[data->numContexts] = ctxData;
  data->numContexts++;
}

Here, the slave context is created, and it's data is stored in the device-wide ExtraData structure. The renderBuffer that is created here is where the rendered sound samples for this slave context will eventually go.

////////////////////  Context Switching 

/* A device brings along with it two pieces of state
 * which have to be swapped in and out with each context.
 */
static void swapInContext(ALCdevice *Device, context_data *ctxData){
  memcpy(Device->ClickRemoval, ctxData->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS);
  memcpy(Device->PendingClicks, ctxData->PendingClicks, sizeof(ALfloat)*MAXCHANNELS);
}

static void saveContext(ALCdevice *Device, context_data *ctxData){
  memcpy(ctxData->ClickRemoval, Device->ClickRemoval, sizeof(ALfloat)*MAXCHANNELS);
  memcpy(ctxData->PendingClicks, Device->PendingClicks, sizeof(ALfloat)*MAXCHANNELS);
}  

static ALCcontext **currentContext;
static ALuint currentNumContext;

/* By default, all contexts are rendered at once for each call to aluMixData.
 * This function uses the internals of the ALCdevice struct to temporally 
 * cause aluMixData to only render the chosen context.
 */
static void limitContext(ALCdevice *Device, ALCcontext *ctx){
  currentContext  = Device->Contexts;
  currentNumContext  = Device->NumContexts;
  Device->Contexts = &ctx;
  Device->NumContexts = 1;
}

static void unLimitContext(ALCdevice *Device){
  Device->Contexts = currentContext;
  Device->NumContexts = currentNumContext;
}

OpenAL normally renders all Contexts in parallel, outputting the whole result to the buffer. It does this by iterating over the Device->Contexts array and rendering each context to the buffer in turn. By temporally setting Device->NumContexts to 1 and adjusting the Device's context list to put the desired context-to-be-rendered into position 0, we can get trick OpenAL into rendering each slave context separate from all the others.

////////////////////   Main Device Loop

/* Establish the LWJGL context as the master context, which will
 * be synchronized to all the slave contexts
 */
static void init(ALCdevice *Device){
  ALCcontext *masterContext = alcGetCurrentContext();
  addContext(Device, masterContext);
}


static void renderData(ALCdevice *Device, int samples){
  if(!Device->Connected){return;}
  send_data *data = (send_data*)Device->ExtraData;
  ALCcontext *current = alcGetCurrentContext();

  ALuint i;
  for (i = 1; i < data->numContexts; i++){
    syncContexts(data->contexts[0]->ctx , data->contexts[i]->ctx);
  }
  
  if ((ALuint) samples > Device->UpdateSize){
    printf("exceeding internal buffer size; dropping samples\n");
    printf("requested %d; available %d\n", samples, Device->UpdateSize);
    samples = (int) Device->UpdateSize;
  }

  for (i = 0; i < data->numContexts; i++){
    context_data *ctxData = data->contexts[i];
    ALCcontext *ctx = ctxData->ctx;
    alcMakeContextCurrent(ctx);
    limitContext(Device, ctx);
    swapInContext(Device, ctxData);
    aluMixData(Device, ctxData->renderBuffer, samples);
    saveContext(Device, ctxData);
    unLimitContext(Device);
  }
  alcMakeContextCurrent(current);
}

The main loop synchronizes the master LWJGL context with all the slave contexts, then walks each context, rendering just that context to it's audio-sample storage buffer.

At this point, we have the ability to create multiple listeners by using the master/slave context trick, and the rendered audio data is waiting patiently in internal buffers, one for each listener. We need a way to transport this information to Java, and also a way to drive this device from Java. The following JNI interface code is inspired by the way LWJGL interfaces with OpenAL.

This code is more-or-less copied verbatim from the other OpenAL backends. It's the basis for OpenAL's primitive object system.

////////////////////   Device Initialization / Management

static const ALCchar sendDevice[] = "Multiple Audio Send";

static ALCboolean send_open_playback(ALCdevice *device, 
 const ALCchar *deviceName)
{
  send_data *data;
  // stop any buffering for stdout, so that I can 
  // see the printf statements in my terminal immediately
  setbuf(stdout, NULL);

  if(!deviceName)
    deviceName = sendDevice;
  else if(strcmp(deviceName, sendDevice) != 0)
    return ALC_FALSE;
  data = (send_data*)calloc(1, sizeof(*data));
  device->szDeviceName = strdup(deviceName);
  device->ExtraData = data;
  return ALC_TRUE;
}

static void send_close_playback(ALCdevice *device)
{
  send_data *data = (send_data*)device->ExtraData;
  alcMakeContextCurrent(NULL);
  ALuint i;
  // Destroy all slave contexts. LWJGL will take care of 
  // its own context.
  for (i = 1; i < data->numContexts; i++){
    context_data *ctxData = data->contexts[i];
    alcDestroyContext(ctxData->ctx);
    free(ctxData->renderBuffer);
    free(ctxData);
  }
  free(data);
  device->ExtraData = NULL;
}

static ALCboolean send_reset_playback(ALCdevice *device)
{
  SetDefaultWFXChannelOrder(device);
  return ALC_TRUE;
}

static void send_stop_playback(ALCdevice *Device){
  UNUSED(Device);
}

static const BackendFuncs send_funcs = {
  send_open_playback,
  send_close_playback,
  send_reset_playback,
  send_stop_playback,
  NULL,
  NULL,  /* These would be filled with functions to    */
  NULL,  /* handle capturing audio if we we into that  */
  NULL,  /* sort of thing...                           */
  NULL,
  NULL
};

ALCboolean alc_send_init(BackendFuncs *func_list){
  *func_list = send_funcs;
  return ALC_TRUE;
}

void alc_send_deinit(void){}

void alc_send_probe(enum DevProbe type)
{
  switch(type)
    {
    case DEVICE_PROBE:
      AppendDeviceList(sendDevice);
      break;
    case ALL_DEVICE_PROBE:
      AppendAllDeviceList(sendDevice);
      break;
    case CAPTURE_DEVICE_PROBE:
      break;
    }
}