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