OpenAL32/alListener.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2000 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include "alMain.h"
  24 #include "AL/alc.h"
  25 #include "alError.h"
  26 #include "alListener.h"
  27 #include "alSource.h"
  28
  29 AL_API ALvoid AL_APIENTRY alListenerf(ALenum eParam, ALfloat flValue)
  30 {
  31     ALCcontext *Context;
  32
  33     Context = GetContextRef();
  34     if(!Context) return;
  35
  36     switch(eParam)
  37     {
  38         case AL_GAIN:
  39             if(flValue >= 0.0f && isfinite(flValue))
  40             {
  41                 Context->Listener.Gain = flValue;
  42                 Context->UpdateSources = AL_TRUE;
  43             }
  44             else
  45                 alSetError(Context, AL_INVALID_VALUE);
  46             break;
  47
  48         case AL_METERS_PER_UNIT:
  49             if(flValue > 0.0f && isfinite(flValue))
  50             {
  51                 Context->Listener.MetersPerUnit = flValue;
  52                 Context->UpdateSources = AL_TRUE;
  53             }
  54             else
  55                 alSetError(Context, AL_INVALID_VALUE);
  56             break;
  57
  58         default:
  59             alSetError(Context, AL_INVALID_ENUM);
  60             break;
  61     }
  62
  63     ALCcontext_DecRef(Context);
  64 }
  65
  66
  67 AL_API ALvoid AL_APIENTRY alListener3f(ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
  68 {
  69     ALCcontext *Context;
  70
  71     Context = GetContextRef();
  72     if(!Context) return;
  73
  74     switch(eParam)
  75     {
  76         case AL_POSITION:
  77             if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
  78             {
  79                 LockContext(Context);
  80                 Context->Listener.Position[0] = flValue1;
  81                 Context->Listener.Position[1] = flValue2;
  82                 Context->Listener.Position[2] = flValue3;
  83                 Context->UpdateSources = AL_TRUE;
  84                 UnlockContext(Context);
  85             }
  86             else
  87                 alSetError(Context, AL_INVALID_VALUE);
  88             break;
  89
  90         case AL_VELOCITY:
  91             if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))
  92             {
  93                 LockContext(Context);
  94                 Context->Listener.Velocity[0] = flValue1;
  95                 Context->Listener.Velocity[1] = flValue2;
  96                 Context->Listener.Velocity[2] = flValue3;
  97                 Context->UpdateSources = AL_TRUE;
  98                 UnlockContext(Context);
  99             }
 100             else
 101                 alSetError(Context, AL_INVALID_VALUE);
 102             break;
 103
 104         default:
 105             alSetError(Context, AL_INVALID_ENUM);
 106             break;
 107     }
 108
 109     ALCcontext_DecRef(Context);
 110 }
 111
 112
 113 AL_API ALvoid AL_APIENTRY alListenerfv(ALenum eParam, const ALfloat *pflValues)
 114 {
 115     ALCcontext *Context;
 116
 117     if(pflValues)
 118     {
 119         switch(eParam)
 120         {
 121             case AL_GAIN:
 122             case AL_METERS_PER_UNIT:
 123                 alListenerf(eParam, pflValues[0]);
 124                 return;
 125
 126             case AL_POSITION:
 127             case AL_VELOCITY:
 128                 alListener3f(eParam, pflValues[0], pflValues[1], pflValues[2]);
 129                 return;
 130         }
 131     }
 132
 133     Context = GetContextRef();
 134     if(!Context) return;
 135
 136     if(pflValues)
 137     {
 138         switch(eParam)
 139         {
 140             case AL_ORIENTATION:
 141                 if(isfinite(pflValues[0]) && isfinite(pflValues[1]) &&
 142                    isfinite(pflValues[2]) && isfinite(pflValues[3]) &&
 143                    isfinite(pflValues[4]) && isfinite(pflValues[5]))
 144                 {
 145                     LockContext(Context);
 146                     // AT then UP
 147                     Context->Listener.Forward[0] = pflValues[0];
 148                     Context->Listener.Forward[1] = pflValues[1];
 149                     Context->Listener.Forward[2] = pflValues[2];
 150                     Context->Listener.Up[0] = pflValues[3];
 151                     Context->Listener.Up[1] = pflValues[4];
 152                     Context->Listener.Up[2] = pflValues[5];
 153                     Context->UpdateSources = AL_TRUE;
 154                     UnlockContext(Context);
 155                 }
 156                 else
 157                     alSetError(Context, AL_INVALID_VALUE);
 158                 break;
 159
 160             default:
 161                 alSetError(Context, AL_INVALID_ENUM);
 162                 break;
 163         }
 164     }
 165     else
 166         alSetError(Context, AL_INVALID_VALUE);
 167
 168     ALCcontext_DecRef(Context);
 169 }
 170
 171
 172 AL_API ALvoid AL_APIENTRY alListeneri(ALenum eParam, ALint lValue)
 173 {
 174     ALCcontext *Context;
 175
 176     (void)lValue;
 177
 178     Context = GetContextRef();
 179     if(!Context) return;
 180
 181     switch(eParam)
 182     {
 183         default:
 184             alSetError(Context, AL_INVALID_ENUM);
 185             break;
 186     }
 187
 188     ALCcontext_DecRef(Context);
 189 }
 190
 191
 192 AL_API void AL_APIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 193 {
 194     ALCcontext *Context;
 195
 196     switch(eParam)
 197     {
 198         case AL_POSITION:
 199         case AL_VELOCITY:
 200             alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
 201             return;
 202     }
 203
 204     Context = GetContextRef();
 205     if(!Context) return;
 206
 207     switch(eParam)
 208     {
 209         default:
 210             alSetError(Context, AL_INVALID_ENUM);
 211             break;
 212     }
 213
 214     ALCcontext_DecRef(Context);
 215 }
 216
 217
 218 AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
 219 {
 220     ALCcontext *Context;
 221     ALfloat flValues[6];
 222
 223     if(plValues)
 224     {
 225         switch(eParam)
 226         {
 227             case AL_POSITION:
 228             case AL_VELOCITY:
 229                 alListener3f(eParam, (ALfloat)plValues[0], (ALfloat)plValues[1], (ALfloat)plValues[2]);
 230                 return;
 231
 232             case AL_ORIENTATION:
 233                 flValues[0] = (ALfloat)plValues[0];
 234                 flValues[1] = (ALfloat)plValues[1];
 235                 flValues[2] = (ALfloat)plValues[2];
 236                 flValues[3] = (ALfloat)plValues[3];
 237                 flValues[4] = (ALfloat)plValues[4];
 238                 flValues[5] = (ALfloat)plValues[5];
 239                 alListenerfv(eParam, flValues);
 240                 return;
 241         }
 242     }
 243
 244     Context = GetContextRef();
 245     if(!Context) return;
 246
 247     if(plValues)
 248     {
 249         switch(eParam)
 250         {
 251             default:
 252                 alSetError(Context, AL_INVALID_ENUM);
 253                 break;
 254         }
 255     }
 256     else
 257         alSetError(Context, AL_INVALID_VALUE);
 258
 259     ALCcontext_DecRef(Context);
 260 }
 261
 262
 263 AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
 264 {
 265     ALCcontext *Context;
 266
 267     Context = GetContextRef();
 268     if(!Context) return;
 269
 270     if(pflValue)
 271     {
 272         switch(eParam)
 273         {
 274             case AL_GAIN:
 275                 *pflValue = Context->Listener.Gain;
 276                 break;
 277
 278             case AL_METERS_PER_UNIT:
 279                 *pflValue = Context->Listener.MetersPerUnit;
 280                 break;
 281
 282             default:
 283                 alSetError(Context, AL_INVALID_ENUM);
 284                 break;
 285         }
 286     }
 287     else
 288         alSetError(Context, AL_INVALID_VALUE);
 289
 290     ALCcontext_DecRef(Context);
 291 }
 292
 293
 294 AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
 295 {
 296     ALCcontext *Context;
 297
 298     Context = GetContextRef();
 299     if(!Context) return;
 300
 301     if(pflValue1 && pflValue2 && pflValue3)
 302     {
 303         switch(eParam)
 304         {
 305             case AL_POSITION:
 306                 LockContext(Context);
 307                 *pflValue1 = Context->Listener.Position[0];
 308                 *pflValue2 = Context->Listener.Position[1];
 309                 *pflValue3 = Context->Listener.Position[2];
 310                 UnlockContext(Context);
 311                 break;
 312
 313             case AL_VELOCITY:
 314                 LockContext(Context);
 315                 *pflValue1 = Context->Listener.Velocity[0];
 316                 *pflValue2 = Context->Listener.Velocity[1];
 317                 *pflValue3 = Context->Listener.Velocity[2];
 318                 UnlockContext(Context);
 319                 break;
 320
 321             default:
 322                 alSetError(Context, AL_INVALID_ENUM);
 323                 break;
 324         }
 325     }
 326     else
 327         alSetError(Context, AL_INVALID_VALUE);
 328
 329     ALCcontext_DecRef(Context);
 330 }
 331
 332
 333 AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
 334 {
 335     ALCcontext *Context;
 336
 337     switch(eParam)
 338     {
 339         case AL_GAIN:
 340         case AL_METERS_PER_UNIT:
 341             alGetListenerf(eParam, pflValues);
 342             return;
 343
 344         case AL_POSITION:
 345         case AL_VELOCITY:
 346             alGetListener3f(eParam, pflValues+0, pflValues+1, pflValues+2);
 347             return;
 348     }
 349
 350     Context = GetContextRef();
 351     if(!Context) return;
 352
 353     if(pflValues)
 354     {
 355         switch(eParam)
 356         {
 357             case AL_ORIENTATION:
 358                 LockContext(Context);
 359                 // AT then UP
 360                 pflValues[0] = Context->Listener.Forward[0];
 361                 pflValues[1] = Context->Listener.Forward[1];
 362                 pflValues[2] = Context->Listener.Forward[2];
 363                 pflValues[3] = Context->Listener.Up[0];
 364                 pflValues[4] = Context->Listener.Up[1];
 365                 pflValues[5] = Context->Listener.Up[2];
 366                 UnlockContext(Context);
 367                 break;
 368
 369             default:
 370                 alSetError(Context, AL_INVALID_ENUM);
 371                 break;
 372         }
 373     }
 374     else
 375         alSetError(Context, AL_INVALID_VALUE);
 376
 377     ALCcontext_DecRef(Context);
 378 }
 379
 380
 381 AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
 382 {
 383     ALCcontext *Context;
 384
 385     Context = GetContextRef();
 386     if(!Context) return;
 387
 388     if(plValue)
 389     {
 390         switch(eParam)
 391         {
 392             default:
 393                 alSetError(Context, AL_INVALID_ENUM);
 394                 break;
 395         }
 396     }
 397     else
 398         alSetError(Context, AL_INVALID_VALUE);
 399
 400     ALCcontext_DecRef(Context);
 401 }
 402
 403
 404 AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
 405 {
 406     ALCcontext *Context;
 407
 408     Context = GetContextRef();
 409     if(!Context) return;
 410
 411     if(plValue1 && plValue2 && plValue3)
 412     {
 413         switch (eParam)
 414         {
 415             case AL_POSITION:
 416                 LockContext(Context);
 417                 *plValue1 = (ALint)Context->Listener.Position[0];
 418                 *plValue2 = (ALint)Context->Listener.Position[1];
 419                 *plValue3 = (ALint)Context->Listener.Position[2];
 420                 UnlockContext(Context);
 421                 break;
 422
 423             case AL_VELOCITY:
 424                 LockContext(Context);
 425                 *plValue1 = (ALint)Context->Listener.Velocity[0];
 426                 *plValue2 = (ALint)Context->Listener.Velocity[1];
 427                 *plValue3 = (ALint)Context->Listener.Velocity[2];
 428                 UnlockContext(Context);
 429                 break;
 430
 431             default:
 432                 alSetError(Context, AL_INVALID_ENUM);
 433                 break;
 434         }
 435     }
 436     else
 437         alSetError(Context, AL_INVALID_VALUE);
 438
 439     ALCcontext_DecRef(Context);
 440 }
 441
 442
 443 AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
 444 {
 445     ALCcontext *Context;
 446
 447     switch(eParam)
 448     {
 449         case AL_POSITION:
 450         case AL_VELOCITY:
 451             alGetListener3i(eParam, plValues+0, plValues+1, plValues+2);
 452             return;
 453     }
 454
 455     Context = GetContextRef();
 456     if(!Context) return;
 457
 458     if(plValues)
 459     {
 460         switch(eParam)
 461         {
 462             case AL_ORIENTATION:
 463                 LockContext(Context);
 464                 // AT then UP
 465                 plValues[0] = (ALint)Context->Listener.Forward[0];
 466                 plValues[1] = (ALint)Context->Listener.Forward[1];
 467                 plValues[2] = (ALint)Context->Listener.Forward[2];
 468                 plValues[3] = (ALint)Context->Listener.Up[0];
 469                 plValues[4] = (ALint)Context->Listener.Up[1];
 470                 plValues[5] = (ALint)Context->Listener.Up[2];
 471                 UnlockContext(Context);
 472                 break;
 473
 474             default:
 475                 alSetError(Context, AL_INVALID_ENUM);
 476                 break;
 477         }
 478     }
 479     else
 480         alSetError(Context, AL_INVALID_VALUE);
 481
 482     ALCcontext_DecRef(Context);
 483 }