examples/alhelpers.c

   1 /*
   2  * OpenAL Helpers
   3  *
   4  * Copyright (c) 2011 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 routines to help with some menial OpenAL-related tasks,
  26  * such as opening a device and setting up a context, closing the device and
  27  * destroying its context, converting between frame counts and byte lengths,
  28  * finding an appropriate buffer format, and getting readable strings for
  29  * channel configs and sample types. */
  30
  31 #include <stdio.h>
  32
  33 #include "AL/al.h"
  34 #include "AL/alc.h"
  35 #include "AL/alext.h"
  36
  37 #include "alhelpers.h"
  38
  39
  40 const char *ChannelsName(ALenum chans)
  41 {
  42     switch(chans)
  43     {
  44     case AL_MONO_SOFT: return "Mono";
  45     case AL_STEREO_SOFT: return "Stereo";
  46     case AL_REAR_SOFT: return "Rear";
  47     case AL_QUAD_SOFT: return "Quadraphonic";
  48     case AL_5POINT1_SOFT: return "5.1 Surround";
  49     case AL_6POINT1_SOFT: return "6.1 Surround";
  50     case AL_7POINT1_SOFT: return "7.1 Surround";
  51     }
  52     return "Unknown Channels";
  53 }
  54
  55 const char *TypeName(ALenum type)
  56 {
  57     switch(type)
  58     {
  59     case AL_BYTE_SOFT: return "S8";
  60     case AL_UNSIGNED_BYTE_SOFT: return "U8";
  61     case AL_SHORT_SOFT: return "S16";
  62     case AL_UNSIGNED_SHORT_SOFT: return "U16";
  63     case AL_INT_SOFT: return "S32";
  64     case AL_UNSIGNED_INT_SOFT: return "U32";
  65     case AL_FLOAT_SOFT: return "Float32";
  66     case AL_DOUBLE_SOFT: return "Float64";
  67     }
  68     return "Unknown Type";
  69 }
  70
  71
  72 ALsizei FramesToBytes(ALsizei size, ALenum channels, ALenum type)
  73 {
  74     switch(channels)
  75     {
  76     case AL_MONO_SOFT:    size *= 1; break;
  77     case AL_STEREO_SOFT:  size *= 2; break;
  78     case AL_REAR_SOFT:    size *= 2; break;
  79     case AL_QUAD_SOFT:    size *= 4; break;
  80     case AL_5POINT1_SOFT: size *= 6; break;
  81     case AL_6POINT1_SOFT: size *= 7; break;
  82     case AL_7POINT1_SOFT: size *= 8; break;
  83     }
  84
  85     switch(type)
  86     {
  87     case AL_BYTE_SOFT:           size *= sizeof(ALbyte); break;
  88     case AL_UNSIGNED_BYTE_SOFT:  size *= sizeof(ALubyte); break;
  89     case AL_SHORT_SOFT:          size *= sizeof(ALshort); break;
  90     case AL_UNSIGNED_SHORT_SOFT: size *= sizeof(ALushort); break;
  91     case AL_INT_SOFT:            size *= sizeof(ALint); break;
  92     case AL_UNSIGNED_INT_SOFT:   size *= sizeof(ALuint); break;
  93     case AL_FLOAT_SOFT:          size *= sizeof(ALfloat); break;
  94     case AL_DOUBLE_SOFT:         size *= sizeof(ALdouble); break;
  95     }
  96
  97     return size;
  98 }
  99
 100 ALsizei BytesToFrames(ALsizei size, ALenum channels, ALenum type)
 101 {
 102     return size / FramesToBytes(1, channels, type);
 103 }
 104
 105
 106 ALenum GetFormat(ALenum channels, ALenum type, LPALISBUFFERFORMATSUPPORTEDSOFT palIsBufferFormatSupportedSOFT)
 107 {
 108     ALenum format = AL_NONE;
 109
 110     /* If using AL_SOFT_buffer_samples, try looking through its formats */
 111     if(palIsBufferFormatSupportedSOFT)
 112     {
 113         /* AL_SOFT_buffer_samples is more lenient with matching formats. The
 114          * specified sample type does not need to match the returned format,
 115          * but it is nice to try to get something close. */
 116         if(type == AL_UNSIGNED_BYTE_SOFT || type == AL_BYTE_SOFT)
 117         {
 118             if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
 119             else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
 120             else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
 121             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
 122             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
 123             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
 124         }
 125         else if(type == AL_UNSIGNED_SHORT_SOFT || type == AL_SHORT_SOFT)
 126         {
 127             if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
 128             else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
 129             else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
 130             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
 131             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
 132             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
 133         }
 134         else if(type == AL_UNSIGNED_BYTE3_SOFT || type == AL_BYTE3_SOFT ||
 135                 type == AL_UNSIGNED_INT_SOFT || type == AL_INT_SOFT ||
 136                 type == AL_FLOAT_SOFT || type == AL_DOUBLE_SOFT)
 137         {
 138             if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
 139             else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
 140             else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
 141             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
 142             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
 143             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
 144         }
 145
 146         if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
 147             format = AL_NONE;
 148
 149         /* A matching format was not found or supported. Try 32-bit float. */
 150         if(format == AL_NONE)
 151         {
 152             if(channels == AL_MONO_SOFT) format = AL_MONO32F_SOFT;
 153             else if(channels == AL_STEREO_SOFT) format = AL_STEREO32F_SOFT;
 154             else if(channels == AL_QUAD_SOFT) format = AL_QUAD32F_SOFT;
 155             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_32F_SOFT;
 156             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_32F_SOFT;
 157             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_32F_SOFT;
 158
 159             if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
 160                 format = AL_NONE;
 161         }
 162         /* 32-bit float not supported. Try 16-bit int. */
 163         if(format == AL_NONE)
 164         {
 165             if(channels == AL_MONO_SOFT) format = AL_MONO16_SOFT;
 166             else if(channels == AL_STEREO_SOFT) format = AL_STEREO16_SOFT;
 167             else if(channels == AL_QUAD_SOFT) format = AL_QUAD16_SOFT;
 168             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_16_SOFT;
 169             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_16_SOFT;
 170             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_16_SOFT;
 171
 172             if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
 173                 format = AL_NONE;
 174         }
 175         /* 16-bit int not supported. Try 8-bit int. */
 176         if(format == AL_NONE)
 177         {
 178             if(channels == AL_MONO_SOFT) format = AL_MONO8_SOFT;
 179             else if(channels == AL_STEREO_SOFT) format = AL_STEREO8_SOFT;
 180             else if(channels == AL_QUAD_SOFT) format = AL_QUAD8_SOFT;
 181             else if(channels == AL_5POINT1_SOFT) format = AL_5POINT1_8_SOFT;
 182             else if(channels == AL_6POINT1_SOFT) format = AL_6POINT1_8_SOFT;
 183             else if(channels == AL_7POINT1_SOFT) format = AL_7POINT1_8_SOFT;
 184
 185             if(format != AL_NONE && !palIsBufferFormatSupportedSOFT(format))
 186                 format = AL_NONE;
 187         }
 188
 189         return format;
 190     }
 191
 192     /* We use the AL_EXT_MCFORMATS extension to provide output of Quad, 5.1,
 193      * and 7.1 channel configs, AL_EXT_FLOAT32 for 32-bit float samples, and
 194      * AL_EXT_DOUBLE for 64-bit float samples. */
 195     if(type == AL_UNSIGNED_BYTE_SOFT)
 196     {
 197         if(channels == AL_MONO_SOFT)
 198             format = AL_FORMAT_MONO8;
 199         else if(channels == AL_STEREO_SOFT)
 200             format = AL_FORMAT_STEREO8;
 201         else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
 202         {
 203             if(channels == AL_QUAD_SOFT)
 204                 format = alGetEnumValue("AL_FORMAT_QUAD8");
 205             else if(channels == AL_5POINT1_SOFT)
 206                 format = alGetEnumValue("AL_FORMAT_51CHN8");
 207             else if(channels == AL_6POINT1_SOFT)
 208                 format = alGetEnumValue("AL_FORMAT_61CHN8");
 209             else if(channels == AL_7POINT1_SOFT)
 210                 format = alGetEnumValue("AL_FORMAT_71CHN8");
 211         }
 212     }
 213     else if(type == AL_SHORT_SOFT)
 214     {
 215         if(channels == AL_MONO_SOFT)
 216             format = AL_FORMAT_MONO16;
 217         else if(channels == AL_STEREO_SOFT)
 218             format = AL_FORMAT_STEREO16;
 219         else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
 220         {
 221             if(channels == AL_QUAD_SOFT)
 222                 format = alGetEnumValue("AL_FORMAT_QUAD16");
 223             else if(channels == AL_5POINT1_SOFT)
 224                 format = alGetEnumValue("AL_FORMAT_51CHN16");
 225             else if(channels == AL_6POINT1_SOFT)
 226                 format = alGetEnumValue("AL_FORMAT_61CHN16");
 227             else if(channels == AL_7POINT1_SOFT)
 228                 format = alGetEnumValue("AL_FORMAT_71CHN16");
 229         }
 230     }
 231     else if(type == AL_FLOAT_SOFT && alIsExtensionPresent("AL_EXT_FLOAT32"))
 232     {
 233         if(channels == AL_MONO_SOFT)
 234             format = alGetEnumValue("AL_FORMAT_MONO_FLOAT32");
 235         else if(channels == AL_STEREO_SOFT)
 236             format = alGetEnumValue("AL_FORMAT_STEREO_FLOAT32");
 237         else if(alIsExtensionPresent("AL_EXT_MCFORMATS"))
 238         {
 239             if(channels == AL_QUAD_SOFT)
 240                 format = alGetEnumValue("AL_FORMAT_QUAD32");
 241             else if(channels == AL_5POINT1_SOFT)
 242                 format = alGetEnumValue("AL_FORMAT_51CHN32");
 243             else if(channels == AL_6POINT1_SOFT)
 244                 format = alGetEnumValue("AL_FORMAT_61CHN32");
 245             else if(channels == AL_7POINT1_SOFT)
 246                 format = alGetEnumValue("AL_FORMAT_71CHN32");
 247         }
 248     }
 249     else if(type == AL_DOUBLE_SOFT && alIsExtensionPresent("AL_EXT_DOUBLE"))
 250     {
 251         if(channels == AL_MONO_SOFT)
 252             format = alGetEnumValue("AL_FORMAT_MONO_DOUBLE");
 253         else if(channels == AL_STEREO_SOFT)
 254             format = alGetEnumValue("AL_FORMAT_STEREO_DOUBLE");
 255     }
 256
 257     /* NOTE: It seems OSX returns -1 from alGetEnumValue for unknown enums, as
 258      * opposed to 0. Correct it. */
 259     if(format == -1)
 260         format = 0;
 261
 262     return format;
 263 }
 264
 265
 266 void AL_APIENTRY wrap_BufferSamples(ALuint buffer, ALuint samplerate,
 267                                     ALenum internalformat, ALsizei samples,
 268                                     ALenum channels, ALenum type,
 269                                     const ALvoid *data)
 270 {
 271     alBufferData(buffer, internalformat, data,
 272                  FramesToBytes(samples, channels, type),
 273                  samplerate);
 274 }
 275
 276
 277 int InitAL(void)
 278 {
 279     ALCdevice *device;
 280     ALCcontext *ctx;
 281
 282     /* Open and initialize a device with default settings */
 283     device = alcOpenDevice(NULL);
 284     if(!device)
 285     {
 286         fprintf(stderr, "Could not open a device!\n");
 287         return 1;
 288     }
 289
 290     ctx = alcCreateContext(device, NULL);
 291     if(ctx == NULL || alcMakeContextCurrent(ctx) == ALC_FALSE)
 292     {
 293         if(ctx != NULL)
 294             alcDestroyContext(ctx);
 295         alcCloseDevice(device);
 296         fprintf(stderr, "Could not set a context!\n");
 297         return 1;
 298     }
 299
 300     return 0;
 301 }
 302
 303 void CloseAL(void)
 304 {
 305     ALCdevice *device;
 306     ALCcontext *ctx;
 307
 308     /* Close the device belonging to the current context, and destroy the
 309      * context. */
 310     ctx = alcGetCurrentContext();
 311     if(ctx == NULL)
 312         return;
 313
 314     device = alcGetContextsDevice(ctx);
 315
 316     alcMakeContextCurrent(NULL);
 317     alcDestroyContext(ctx);
 318     alcCloseDevice(device);
 319 }