examples/alloopback.c

   1 /*
   2  * OpenAL Loopback Example
   3  *
   4  * Copyright (c) 2013 by Chris Robinson <chris.kcat@gmail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 /* This file contains an example for using the loopback device for custom
  26  * output handling.
  27  */
  28
  29 #include <stdio.h>
  30 #include <assert.h>
  31 #include <math.h>
  32
  33 #include <SDL.h>
  34
  35 #include "AL/al.h"
  36 #include "AL/alc.h"
  37 #include "AL/alext.h"
  38
  39 #include "common/alhelpers.h"
  40
  41 #ifndef M_PI
  42 #define M_PI    (3.14159265358979323846)
  43 #endif
  44
  45 typedef struct {
  46     ALCdevice *Device;
  47     ALCcontext *Context;
  48
  49     ALCsizei FrameSize;
  50 } PlaybackInfo;
  51
  52 static LPALCLOOPBACKOPENDEVICESOFT alcLoopbackOpenDeviceSOFT;
  53 static LPALCISRENDERFORMATSUPPORTEDSOFT alcIsRenderFormatSupportedSOFT;
  54 static LPALCRENDERSAMPLESSOFT alcRenderSamplesSOFT;
  55
  56
  57 void SDLCALL RenderSDLSamples(void *userdata, Uint8 *stream, int len)
  58 {
  59     PlaybackInfo *playback = (PlaybackInfo*)userdata;
  60     alcRenderSamplesSOFT(playback->Device, stream, len/playback->FrameSize);
  61 }
  62
  63
  64 /* Creates a one second buffer containing a sine wave, and returns the new
  65  * buffer ID. */
  66 static ALuint CreateSineWave(void)
  67 {
  68     ALshort data[44100];
  69     ALuint buffer;
  70     ALenum err;
  71     ALuint i;
  72
  73     for(i = 0;i < 44100;i++)
  74         data[i] = (ALshort)(sin(i * 441.0 / 44100.0 * 2.0*M_PI)*32767.0);
  75
  76     /* Buffer the audio data into a new buffer object. */
  77     buffer = 0;
  78     alGenBuffers(1, &buffer);
  79     alBufferData(buffer, AL_FORMAT_MONO16, data, sizeof(data), 44100);
  80
  81     /* Check if an error occured, and clean up if so. */
  82     err = alGetError();
  83     if(err != AL_NO_ERROR)
  84     {
  85         fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
  86         if(alIsBuffer(buffer))
  87             alDeleteBuffers(1, &buffer);
  88         return 0;
  89     }
  90
  91     return buffer;
  92 }
  93
  94
  95 int main()
  96 {
  97     PlaybackInfo playback = { NULL, NULL, 0 };
  98     SDL_AudioSpec desired, obtained;
  99     ALuint source, buffer;
 100     ALCint attrs[16];
 101     ALenum state;
 102
 103     /* Print out error if extension is missing. */
 104     if(!alcIsExtensionPresent(NULL, "ALC_SOFT_loopback"))
 105     {
 106         fprintf(stderr, "Error: ALC_SOFT_loopback not supported!\n");
 107         return 1;
 108     }
 109
 110     /* Define a macro to help load the function pointers. */
 111 #define LOAD_PROC(x)  ((x) = alcGetProcAddress(NULL, #x))
 112     LOAD_PROC(alcLoopbackOpenDeviceSOFT);
 113     LOAD_PROC(alcIsRenderFormatSupportedSOFT);
 114     LOAD_PROC(alcRenderSamplesSOFT);
 115 #undef LOAD_PROC
 116
 117     if(SDL_Init(SDL_INIT_AUDIO) == -1)
 118     {
 119         fprintf(stderr, "Failed to init SDL audio: %s\n", SDL_GetError());
 120         return 1;
 121     }
 122
 123     /* Set up SDL audio with our requested format and callback. */
 124     desired.channels = 2;
 125     desired.format = AUDIO_S16SYS;
 126     desired.freq = 44100;
 127     desired.padding = 0;
 128     desired.samples = 4096;
 129     desired.callback = RenderSDLSamples;
 130     desired.userdata = &playback;
 131     if(SDL_OpenAudio(&desired, &obtained) != 0)
 132     {
 133         SDL_Quit();
 134         fprintf(stderr, "Failed to open SDL audio: %s\n", SDL_GetError());
 135         return 1;
 136     }
 137
 138     /* Set up our OpenAL attributes based on what we got from SDL. */
 139     attrs[0] = ALC_FORMAT_CHANNELS_SOFT;
 140     if(obtained.channels == 1)
 141         attrs[1] = ALC_MONO_SOFT;
 142     else if(obtained.channels == 2)
 143         attrs[1] = ALC_STEREO_SOFT;
 144     else
 145     {
 146         fprintf(stderr, "Unhandled SDL channel count: %d\n", obtained.channels);
 147         goto error;
 148     }
 149
 150     attrs[2] = ALC_FORMAT_TYPE_SOFT;
 151     if(obtained.format == AUDIO_U8)
 152         attrs[3] = ALC_UNSIGNED_BYTE_SOFT;
 153     else if(obtained.format == AUDIO_S8)
 154         attrs[3] = ALC_BYTE_SOFT;
 155     else if(obtained.format == AUDIO_U16SYS)
 156         attrs[3] = ALC_UNSIGNED_SHORT_SOFT;
 157     else if(obtained.format == AUDIO_S16SYS)
 158         attrs[3] = ALC_SHORT_SOFT;
 159     else
 160     {
 161         fprintf(stderr, "Unhandled SDL format: 0x%04x\n", obtained.format);
 162         goto error;
 163     }
 164
 165     attrs[4] = ALC_FREQUENCY;
 166     attrs[5] = obtained.freq;
 167
 168     attrs[6] = 0; /* end of list */
 169
 170     /* Initialize OpenAL loopback device, using our format attributes. */
 171     playback.Device = alcLoopbackOpenDeviceSOFT(NULL);
 172     if(!playback.Device)
 173     {
 174         fprintf(stderr, "Failed to open loopback device!\n");
 175         goto error;
 176     }
 177     /* Make sure the format is supported before setting them on the device. */
 178     if(alcIsRenderFormatSupportedSOFT(playback.Device, attrs[5], attrs[1], attrs[3]) == ALC_FALSE)
 179     {
 180         fprintf(stderr, "Render format not supported: %s, %s, %dhz\n",
 181                         ChannelsName(attrs[1]), TypeName(attrs[3]), attrs[5]);
 182         goto error;
 183     }
 184     playback.Context = alcCreateContext(playback.Device, attrs);
 185     if(!playback.Context || alcMakeContextCurrent(playback.Context) == ALC_FALSE)
 186     {
 187         fprintf(stderr, "Failed to set an OpenAL audio context\n");
 188         goto error;
 189     }
 190     playback.FrameSize = FramesToBytes(1, attrs[1], attrs[3]);
 191
 192     /* Start SDL playing. Our callback (thus alcRenderSamplesSOFT) will now
 193      * start being called regularly to update the AL playback state. */
 194     SDL_PauseAudio(0);
 195
 196     /* Load the sound into a buffer. */
 197     buffer = CreateSineWave();
 198     if(!buffer)
 199     {
 200         SDL_CloseAudio();
 201         alcDestroyContext(playback.Context);
 202         alcCloseDevice(playback.Device);
 203         SDL_Quit();
 204         return 1;
 205     }
 206
 207     /* Create the source to play the sound with. */
 208     source = 0;
 209     alGenSources(1, &source);
 210     alSourcei(source, AL_BUFFER, buffer);
 211     assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
 212
 213     /* Play the sound until it finishes. */
 214     alSourcePlay(source);
 215     do {
 216         Sleep(10);
 217         alGetSourcei(source, AL_SOURCE_STATE, &state);
 218     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
 219
 220     /* All done. Delete resources, and close OpenAL. */
 221     alDeleteSources(1, &source);
 222     alDeleteBuffers(1, &buffer);
 223
 224     /* Stop SDL playing. */
 225     SDL_PauseAudio(1);
 226
 227     /* Close up OpenAL and SDL. */
 228     SDL_CloseAudio();
 229     alcDestroyContext(playback.Context);
 230     alcCloseDevice(playback.Device);
 231     SDL_Quit();
 232
 233     return 0;
 234
 235 error:
 236     SDL_CloseAudio();
 237     if(playback.Context)
 238         alcDestroyContext(playback.Context);
 239     if(playback.Device)
 240         alcCloseDevice(playback.Device);
 241     SDL_Quit();
 242
 243     return 1;
 244 }