examples/alhrtf.c

   1 /*
   2  * OpenAL HRTF Example
   3  *
   4  * Copyright (c) 2015 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 selecting an HRTF. */
  26
  27 #include <stdio.h>
  28 #include <assert.h>
  29 #include <math.h>
  30
  31 #include <SDL_sound.h>
  32
  33 #include "AL/al.h"
  34 #include "AL/alc.h"
  35 #include "AL/alext.h"
  36
  37 #include "common/alhelpers.h"
  38
  39
  40 #ifndef M_PI
  41 #define M_PI                         (3.14159265358979323846)
  42 #endif
  43
  44 static LPALCGETSTRINGISOFT alcGetStringiSOFT;
  45 static LPALCRESETDEVICESOFT alcResetDeviceSOFT;
  46
  47 /* LoadBuffer loads the named audio file into an OpenAL buffer object, and
  48  * returns the new buffer ID.
  49  */
  50 static ALuint LoadSound(const char *filename)
  51 {
  52     Sound_Sample *sample;
  53     ALenum err, format;
  54     ALuint buffer;
  55     Uint32 slen;
  56
  57     /* Open the audio file */
  58     sample = Sound_NewSampleFromFile(filename, NULL, 65536);
  59     if(!sample)
  60     {
  61         fprintf(stderr, "Could not open audio in %s\n", filename);
  62         return 0;
  63     }
  64
  65     /* Get the sound format, and figure out the OpenAL format */
  66     if(sample->actual.channels == 1)
  67     {
  68         if(sample->actual.format == AUDIO_U8)
  69             format = AL_FORMAT_MONO8;
  70         else if(sample->actual.format == AUDIO_S16SYS)
  71             format = AL_FORMAT_MONO16;
  72         else
  73         {
  74             fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
  75             Sound_FreeSample(sample);
  76             return 0;
  77         }
  78     }
  79     else if(sample->actual.channels == 2)
  80     {
  81         if(sample->actual.format == AUDIO_U8)
  82             format = AL_FORMAT_STEREO8;
  83         else if(sample->actual.format == AUDIO_S16SYS)
  84             format = AL_FORMAT_STEREO16;
  85         else
  86         {
  87             fprintf(stderr, "Unsupported sample format: 0x%04x\n", sample->actual.format);
  88             Sound_FreeSample(sample);
  89             return 0;
  90         }
  91     }
  92     else
  93     {
  94         fprintf(stderr, "Unsupported channel count: %d\n", sample->actual.channels);
  95         Sound_FreeSample(sample);
  96         return 0;
  97     }
  98
  99     /* Decode the whole audio stream to a buffer. */
 100     slen = Sound_DecodeAll(sample);
 101     if(!sample->buffer || slen == 0)
 102     {
 103         fprintf(stderr, "Failed to read audio from %s\n", filename);
 104         Sound_FreeSample(sample);
 105         return 0;
 106     }
 107
 108     /* Buffer the audio data into a new buffer object, then free the data and
 109      * close the file. */
 110     buffer = 0;
 111     alGenBuffers(1, &buffer);
 112     alBufferData(buffer, format, sample->buffer, slen, sample->actual.rate);
 113     Sound_FreeSample(sample);
 114
 115     /* Check if an error occured, and clean up if so. */
 116     err = alGetError();
 117     if(err != AL_NO_ERROR)
 118     {
 119         fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
 120         if(buffer && alIsBuffer(buffer))
 121             alDeleteBuffers(1, &buffer);
 122         return 0;
 123     }
 124
 125     return buffer;
 126 }
 127
 128
 129 int main(int argc, char **argv)
 130 {
 131     ALCdevice *device;
 132     ALboolean has_angle_ext;
 133     ALuint source, buffer;
 134     const char *soundname;
 135     const char *hrtfname;
 136     ALCint hrtf_state;
 137     ALCint num_hrtf;
 138     ALdouble angle;
 139     ALenum state;
 140
 141     /* Print out usage if no arguments were specified */
 142     if(argc < 2)
 143     {
 144         fprintf(stderr, "Usage: %s [-device <name>] [-hrtf <name>] <soundfile>\n", argv[0]);
 145         return 1;
 146     }
 147
 148     /* Initialize OpenAL, and check for HRTF support. */
 149     argv++; argc--;
 150     if(InitAL(&argv, &argc) != 0)
 151         return 1;
 152
 153     device = alcGetContextsDevice(alcGetCurrentContext());
 154     if(!alcIsExtensionPresent(device, "ALC_SOFT_HRTF"))
 155     {
 156         fprintf(stderr, "Error: ALC_SOFT_HRTF not supported\n");
 157         CloseAL();
 158         return 1;
 159     }
 160
 161     /* Define a macro to help load the function pointers. */
 162 #define LOAD_PROC(d, x)  ((x) = alcGetProcAddress((d), #x))
 163     LOAD_PROC(device, alcGetStringiSOFT);
 164     LOAD_PROC(device, alcResetDeviceSOFT);
 165 #undef LOAD_PROC
 166
 167     /* Check for the AL_EXT_STEREO_ANGLES extension to be able to also rotate
 168      * stereo sources.
 169      */
 170     has_angle_ext = alIsExtensionPresent("AL_EXT_STEREO_ANGLES");
 171     printf("AL_EXT_STEREO_ANGLES%s found\n", has_angle_ext?"":" not");
 172
 173     /* Check for user-preferred HRTF */
 174     if(strcmp(argv[0], "-hrtf") == 0)
 175     {
 176         hrtfname = argv[1];
 177         soundname = argv[2];
 178     }
 179     else
 180     {
 181         hrtfname = NULL;
 182         soundname = argv[0];
 183     }
 184
 185     /* Enumerate available HRTFs, and reset the device using one. */
 186     alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
 187     if(!num_hrtf)
 188         printf("No HRTFs found\n");
 189     else
 190     {
 191         ALCint attr[5];
 192         ALCint index = -1;
 193         ALCint i;
 194
 195         printf("Available HRTFs:\n");
 196         for(i = 0;i < num_hrtf;i++)
 197         {
 198             const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
 199             printf("    %d: %s\n", i, name);
 200
 201             /* Check if this is the HRTF the user requested. */
 202             if(hrtfname && strcmp(name, hrtfname) == 0)
 203                 index = i;
 204         }
 205
 206         i = 0;
 207         attr[i++] = ALC_HRTF_SOFT;
 208         attr[i++] = ALC_TRUE;
 209         if(index == -1)
 210         {
 211             if(hrtfname)
 212                 printf("HRTF \"%s\" not found\n", hrtfname);
 213             printf("Using default HRTF...\n");
 214         }
 215         else
 216         {
 217             printf("Selecting HRTF %d...\n", index);
 218             attr[i++] = ALC_HRTF_ID_SOFT;
 219             attr[i++] = index;
 220         }
 221         attr[i] = 0;
 222
 223         if(!alcResetDeviceSOFT(device, attr))
 224             printf("Failed to reset device: %s\n", alcGetString(device, alcGetError(device)));
 225     }
 226
 227     /* Check if HRTF is enabled, and show which is being used. */
 228     alcGetIntegerv(device, ALC_HRTF_SOFT, 1, &hrtf_state);
 229     if(!hrtf_state)
 230         printf("HRTF not enabled!\n");
 231     else
 232     {
 233         const ALchar *name = alcGetString(device, ALC_HRTF_SPECIFIER_SOFT);
 234         printf("HRTF enabled, using %s\n", name);
 235     }
 236     fflush(stdout);
 237
 238     /* Initialize SDL_sound. */
 239     Sound_Init();
 240
 241     /* Load the sound into a buffer. */
 242     buffer = LoadSound(soundname);
 243     if(!buffer)
 244     {
 245         Sound_Quit();
 246         CloseAL();
 247         return 1;
 248     }
 249
 250     /* Create the source to play the sound with. */
 251     source = 0;
 252     alGenSources(1, &source);
 253     alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
 254     alSource3f(source, AL_POSITION, 0.0f, 0.0f, -1.0f);
 255     alSourcei(source, AL_BUFFER, buffer);
 256     assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
 257
 258     /* Play the sound until it finishes. */
 259     angle = 0.0;
 260     alSourcePlay(source);
 261     do {
 262         al_nssleep(10000000);
 263
 264         /* Rotate the source around the listener by about 1/4 cycle per second,
 265          * and keep it within -pi...+pi.
 266          */
 267         angle += 0.01 * M_PI * 0.5;
 268         if(angle > M_PI)
 269             angle -= M_PI*2.0;
 270
 271         /* This only rotates mono sounds. */
 272         alSource3f(source, AL_POSITION, (ALfloat)sin(angle), 0.0f, -(ALfloat)cos(angle));
 273
 274         if(has_angle_ext)
 275         {
 276             /* This rotates stereo sounds with the AL_EXT_STEREO_ANGLES
 277              * extension. Angles are specified counter-clockwise in radians.
 278              */
 279             ALfloat angles[2] = { (ALfloat)(M_PI/6.0 - angle), (ALfloat)(-M_PI/6.0 - angle) };
 280             alSourcefv(source, AL_STEREO_ANGLES, angles);
 281         }
 282
 283         alGetSourcei(source, AL_SOURCE_STATE, &state);
 284     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
 285
 286     /* All done. Delete resources, and close down SDL_sound and OpenAL. */
 287     alDeleteSources(1, &source);
 288     alDeleteBuffers(1, &buffer);
 289
 290     Sound_Quit();
 291     CloseAL();
 292
 293     return 0;
 294 }