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 "AL/al.h"
  32 #include "AL/alc.h"
  33 #include "AL/alext.h"
  34
  35 #include "common/alhelpers.h"
  36 #include "common/sdl_sound.h"
  37
  38
  39 #ifndef M_PI
  40 #define M_PI                         (3.14159265358979323846)
  41 #endif
  42
  43 static LPALCGETSTRINGISOFT alcGetStringiSOFT;
  44 static LPALCRESETDEVICESOFT alcResetDeviceSOFT;
  45
  46 /* LoadBuffer loads the named audio file into an OpenAL buffer object, and
  47  * returns the new buffer ID. */
  48 static ALuint LoadSound(const char *filename)
  49 {
  50     ALenum err, format, type, channels;
  51     ALuint rate, buffer;
  52     size_t datalen;
  53     void *data;
  54     FilePtr sound;
  55
  56     /* Open the audio file */
  57     sound = openAudioFile(filename, 1000);
  58     if(!sound)
  59     {
  60         fprintf(stderr, "Could not open audio in %s\n", filename);
  61         closeAudioFile(sound);
  62         return 0;
  63     }
  64
  65     /* Get the sound format, and figure out the OpenAL format */
  66     if(getAudioInfo(sound, &rate, &channels, &type) != 0)
  67     {
  68         fprintf(stderr, "Error getting audio info for %s\n", filename);
  69         closeAudioFile(sound);
  70         return 0;
  71     }
  72
  73     format = GetFormat(channels, type, NULL);
  74     if(format == AL_NONE)
  75     {
  76         fprintf(stderr, "Unsupported format (%s, %s) for %s\n",
  77                 ChannelsName(channels), TypeName(type), filename);
  78         closeAudioFile(sound);
  79         return 0;
  80     }
  81
  82     /* Decode the whole audio stream to a buffer. */
  83     data = decodeAudioStream(sound, &datalen);
  84     if(!data)
  85     {
  86         fprintf(stderr, "Failed to read audio from %s\n", filename);
  87         closeAudioFile(sound);
  88         return 0;
  89     }
  90
  91     /* Buffer the audio data into a new buffer object, then free the data and
  92      * close the file. */
  93     buffer = 0;
  94     alGenBuffers(1, &buffer);
  95     alBufferData(buffer, format, data, datalen, rate);
  96     free(data);
  97     closeAudioFile(sound);
  98
  99     /* Check if an error occured, and clean up if so. */
 100     err = alGetError();
 101     if(err != AL_NO_ERROR)
 102     {
 103         fprintf(stderr, "OpenAL Error: %s\n", alGetString(err));
 104         if(buffer && alIsBuffer(buffer))
 105             alDeleteBuffers(1, &buffer);
 106         return 0;
 107     }
 108
 109     return buffer;
 110 }
 111
 112
 113 int main(int argc, char **argv)
 114 {
 115     ALCdevice *device;
 116     ALuint source, buffer;
 117     const char *soundname;
 118     const char *hrtfname;
 119     ALCint hrtf_state;
 120     ALCint num_hrtf;
 121     ALdouble angle;
 122     ALenum state;
 123
 124     /* Print out usage if no file was specified */
 125     if(argc < 2 || (strcmp(argv[1], "-hrtf") == 0 && argc < 4))
 126     {
 127         fprintf(stderr, "Usage: %s [-hrtf <name>] <soundfile>\n", argv[0]);
 128         return 1;
 129     }
 130
 131     /* Initialize OpenAL with the default device, and check for HRTF support. */
 132     if(InitAL() != 0)
 133         return 1;
 134
 135     if(strcmp(argv[1], "-hrtf") == 0)
 136     {
 137         hrtfname = argv[2];
 138         soundname = argv[3];
 139     }
 140     else
 141     {
 142         hrtfname = NULL;
 143         soundname = argv[1];
 144     }
 145
 146     device = alcGetContextsDevice(alcGetCurrentContext());
 147     if(!alcIsExtensionPresent(device, "ALC_SOFT_HRTF"))
 148     {
 149         fprintf(stderr, "Error: ALC_SOFT_HRTF not supported\n");
 150         CloseAL();
 151         return 1;
 152     }
 153
 154     /* Define a macro to help load the function pointers. */
 155 #define LOAD_PROC(d, x)  ((x) = alcGetProcAddress((d), #x))
 156     LOAD_PROC(device, alcGetStringiSOFT);
 157     LOAD_PROC(device, alcResetDeviceSOFT);
 158 #undef LOAD_PROC
 159
 160     /* Enumerate available HRTFs, and reset the device using one. */
 161     alcGetIntegerv(device, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtf);
 162     if(!num_hrtf)
 163         printf("No HRTFs found\n");
 164     else
 165     {
 166         ALCint attr[5];
 167         ALCint index = -1;
 168         ALCint i;
 169
 170         printf("Available HRTFs:\n");
 171         for(i = 0;i < num_hrtf;i++)
 172         {
 173             const ALCchar *name = alcGetStringiSOFT(device, ALC_HRTF_SPECIFIER_SOFT, i);
 174             printf("    %d: %s\n", i, name);
 175
 176             /* Check if this is the HRTF the user requested. */
 177             if(hrtfname && strcmp(name, hrtfname) == 0)
 178                 index = i;
 179         }
 180
 181         if(index == -1)
 182         {
 183             if(hrtfname)
 184                 printf("HRTF \"%s\" not found\n", hrtfname);
 185             index = 0;
 186         }
 187         printf("Selecting HRTF %d...\n", index);
 188
 189         attr[0] = ALC_HRTF_SOFT;
 190         attr[1] = ALC_TRUE;
 191         attr[2] = ALC_HRTF_ID_SOFT;
 192         attr[3] = index;
 193         attr[4] = 0;
 194
 195         if(!alcResetDeviceSOFT(device, attr))
 196             printf("Failed to reset device: %s\n", alcGetString(device, alcGetError(device)));
 197     }
 198
 199     /* Check if HRTF is enabled, and show which is being used. */
 200     alcGetIntegerv(device, ALC_HRTF_SOFT, 1, &hrtf_state);
 201     if(!hrtf_state)
 202         printf("HRTF not enabled!\n");
 203     else
 204     {
 205         const ALchar *name = alcGetString(device, ALC_HRTF_SPECIFIER_SOFT);
 206         printf("HRTF enabled, using %s\n", name);
 207     }
 208     fflush(stdout);
 209
 210     /* Load the sound into a buffer. */
 211     buffer = LoadSound(soundname);
 212     if(!buffer)
 213     {
 214         CloseAL();
 215         return 1;
 216     }
 217
 218     /* Create the source to play the sound with. */
 219     source = 0;
 220     alGenSources(1, &source);
 221     alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
 222     alSource3f(source, AL_POSITION, 0.0f, 0.0f, -1.0f);
 223     alSourcei(source, AL_BUFFER, buffer);
 224     assert(alGetError()==AL_NO_ERROR && "Failed to setup sound source");
 225
 226     /* Play the sound until it finishes. */
 227     angle = 0.0;
 228     alSourcePlay(source);
 229     do {
 230         al_nssleep(10000000);
 231
 232         /* Rotate the source around the listener by about 1/4 cycle per second.
 233          * Only affects mono sounds.
 234          */
 235         angle += 0.01 * M_PI * 0.5;
 236         alSource3f(source, AL_POSITION, (ALfloat)sin(angle), 0.0f, -(ALfloat)cos(angle));
 237
 238         alGetSourcei(source, AL_SOURCE_STATE, &state);
 239     } while(alGetError() == AL_NO_ERROR && state == AL_PLAYING);
 240
 241     /* All done. Delete resources, and close OpenAL. */
 242     alDeleteSources(1, &source);
 243     alDeleteBuffers(1, &buffer);
 244
 245     CloseAL();
 246
 247     return 0;
 248 }