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                     ALfloat U[3], V[3], N[3];
 146
 147                     /* AT then UP */
 148                     N[0] = pflValues[0];
 149                     N[1] = pflValues[1];
 150                     N[2] = pflValues[2];
 151                     aluNormalize(N);
 152                     V[0] = pflValues[3];
 153                     V[1] = pflValues[4];
 154                     V[2] = pflValues[5];
 155                     aluNormalize(V);
 156                     /* Build and normalize right-vector */
 157                     aluCrossproduct(N, V, U);
 158                     aluNormalize(U);
 159
 160                     LockContext(Context);
 161                     Context->Listener.Forward[0] = pflValues[0];
 162                     Context->Listener.Forward[1] = pflValues[1];
 163                     Context->Listener.Forward[2] = pflValues[2];
 164                     Context->Listener.Up[0] = pflValues[3];
 165                     Context->Listener.Up[1] = pflValues[4];
 166                     Context->Listener.Up[2] = pflValues[5];
 167                     Context->Listener.Matrix[0][0] =  U[0];
 168                     Context->Listener.Matrix[0][1] =  V[0];
 169                     Context->Listener.Matrix[0][2] = -N[0];
 170                     Context->Listener.Matrix[0][3] =  0.0f;
 171                     Context->Listener.Matrix[1][0] =  U[1];
 172                     Context->Listener.Matrix[1][1] =  V[1];
 173                     Context->Listener.Matrix[1][2] = -N[1];
 174                     Context->Listener.Matrix[1][3] =  0.0f;
 175                     Context->Listener.Matrix[2][0] =  U[2];
 176                     Context->Listener.Matrix[2][1] =  V[2];
 177                     Context->Listener.Matrix[2][2] = -N[2];
 178                     Context->Listener.Matrix[2][3] =  0.0f;
 179                     Context->Listener.Matrix[3][0] =  0.0f;
 180                     Context->Listener.Matrix[3][1] =  0.0f;
 181                     Context->Listener.Matrix[3][2] =  0.0f;
 182                     Context->Listener.Matrix[3][3] =  1.0f;
 183                     Context->UpdateSources = AL_TRUE;
 184                     UnlockContext(Context);
 185                 }
 186                 else
 187                     alSetError(Context, AL_INVALID_VALUE);
 188                 break;
 189
 190             default:
 191                 alSetError(Context, AL_INVALID_ENUM);
 192                 break;
 193         }
 194     }
 195     else
 196         alSetError(Context, AL_INVALID_VALUE);
 197
 198     ALCcontext_DecRef(Context);
 199 }
 200
 201
 202 AL_API ALvoid AL_APIENTRY alListeneri(ALenum eParam, ALint lValue)
 203 {
 204     ALCcontext *Context;
 205
 206     (void)lValue;
 207
 208     Context = GetContextRef();
 209     if(!Context) return;
 210
 211     switch(eParam)
 212     {
 213         default:
 214             alSetError(Context, AL_INVALID_ENUM);
 215             break;
 216     }
 217
 218     ALCcontext_DecRef(Context);
 219 }
 220
 221
 222 AL_API void AL_APIENTRY alListener3i(ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 223 {
 224     ALCcontext *Context;
 225
 226     switch(eParam)
 227     {
 228         case AL_POSITION:
 229         case AL_VELOCITY:
 230             alListener3f(eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
 231             return;
 232     }
 233
 234     Context = GetContextRef();
 235     if(!Context) return;
 236
 237     switch(eParam)
 238     {
 239         default:
 240             alSetError(Context, AL_INVALID_ENUM);
 241             break;
 242     }
 243
 244     ALCcontext_DecRef(Context);
 245 }
 246
 247
 248 AL_API void AL_APIENTRY alListeneriv( ALenum eParam, const ALint* plValues )
 249 {
 250     ALCcontext *Context;
 251     ALfloat flValues[6];
 252
 253     if(plValues)
 254     {
 255         switch(eParam)
 256         {
 257             case AL_POSITION:
 258             case AL_VELOCITY:
 259                 alListener3f(eParam, (ALfloat)plValues[0], (ALfloat)plValues[1], (ALfloat)plValues[2]);
 260                 return;
 261
 262             case AL_ORIENTATION:
 263                 flValues[0] = (ALfloat)plValues[0];
 264                 flValues[1] = (ALfloat)plValues[1];
 265                 flValues[2] = (ALfloat)plValues[2];
 266                 flValues[3] = (ALfloat)plValues[3];
 267                 flValues[4] = (ALfloat)plValues[4];
 268                 flValues[5] = (ALfloat)plValues[5];
 269                 alListenerfv(eParam, flValues);
 270                 return;
 271         }
 272     }
 273
 274     Context = GetContextRef();
 275     if(!Context) return;
 276
 277     if(plValues)
 278     {
 279         switch(eParam)
 280         {
 281             default:
 282                 alSetError(Context, AL_INVALID_ENUM);
 283                 break;
 284         }
 285     }
 286     else
 287         alSetError(Context, AL_INVALID_VALUE);
 288
 289     ALCcontext_DecRef(Context);
 290 }
 291
 292
 293 AL_API ALvoid AL_APIENTRY alGetListenerf(ALenum eParam, ALfloat *pflValue)
 294 {
 295     ALCcontext *Context;
 296
 297     Context = GetContextRef();
 298     if(!Context) return;
 299
 300     if(pflValue)
 301     {
 302         switch(eParam)
 303         {
 304             case AL_GAIN:
 305                 *pflValue = Context->Listener.Gain;
 306                 break;
 307
 308             case AL_METERS_PER_UNIT:
 309                 *pflValue = Context->Listener.MetersPerUnit;
 310                 break;
 311
 312             default:
 313                 alSetError(Context, AL_INVALID_ENUM);
 314                 break;
 315         }
 316     }
 317     else
 318         alSetError(Context, AL_INVALID_VALUE);
 319
 320     ALCcontext_DecRef(Context);
 321 }
 322
 323
 324 AL_API ALvoid AL_APIENTRY alGetListener3f(ALenum eParam, ALfloat *pflValue1, ALfloat *pflValue2, ALfloat *pflValue3)
 325 {
 326     ALCcontext *Context;
 327
 328     Context = GetContextRef();
 329     if(!Context) return;
 330
 331     if(pflValue1 && pflValue2 && pflValue3)
 332     {
 333         switch(eParam)
 334         {
 335             case AL_POSITION:
 336                 LockContext(Context);
 337                 *pflValue1 = Context->Listener.Position[0];
 338                 *pflValue2 = Context->Listener.Position[1];
 339                 *pflValue3 = Context->Listener.Position[2];
 340                 UnlockContext(Context);
 341                 break;
 342
 343             case AL_VELOCITY:
 344                 LockContext(Context);
 345                 *pflValue1 = Context->Listener.Velocity[0];
 346                 *pflValue2 = Context->Listener.Velocity[1];
 347                 *pflValue3 = Context->Listener.Velocity[2];
 348                 UnlockContext(Context);
 349                 break;
 350
 351             default:
 352                 alSetError(Context, AL_INVALID_ENUM);
 353                 break;
 354         }
 355     }
 356     else
 357         alSetError(Context, AL_INVALID_VALUE);
 358
 359     ALCcontext_DecRef(Context);
 360 }
 361
 362
 363 AL_API ALvoid AL_APIENTRY alGetListenerfv(ALenum eParam, ALfloat *pflValues)
 364 {
 365     ALCcontext *Context;
 366
 367     switch(eParam)
 368     {
 369         case AL_GAIN:
 370         case AL_METERS_PER_UNIT:
 371             alGetListenerf(eParam, pflValues);
 372             return;
 373
 374         case AL_POSITION:
 375         case AL_VELOCITY:
 376             alGetListener3f(eParam, pflValues+0, pflValues+1, pflValues+2);
 377             return;
 378     }
 379
 380     Context = GetContextRef();
 381     if(!Context) return;
 382
 383     if(pflValues)
 384     {
 385         switch(eParam)
 386         {
 387             case AL_ORIENTATION:
 388                 LockContext(Context);
 389                 // AT then UP
 390                 pflValues[0] = Context->Listener.Forward[0];
 391                 pflValues[1] = Context->Listener.Forward[1];
 392                 pflValues[2] = Context->Listener.Forward[2];
 393                 pflValues[3] = Context->Listener.Up[0];
 394                 pflValues[4] = Context->Listener.Up[1];
 395                 pflValues[5] = Context->Listener.Up[2];
 396                 UnlockContext(Context);
 397                 break;
 398
 399             default:
 400                 alSetError(Context, AL_INVALID_ENUM);
 401                 break;
 402         }
 403     }
 404     else
 405         alSetError(Context, AL_INVALID_VALUE);
 406
 407     ALCcontext_DecRef(Context);
 408 }
 409
 410
 411 AL_API ALvoid AL_APIENTRY alGetListeneri(ALenum eParam, ALint *plValue)
 412 {
 413     ALCcontext *Context;
 414
 415     Context = GetContextRef();
 416     if(!Context) return;
 417
 418     if(plValue)
 419     {
 420         switch(eParam)
 421         {
 422             default:
 423                 alSetError(Context, AL_INVALID_ENUM);
 424                 break;
 425         }
 426     }
 427     else
 428         alSetError(Context, AL_INVALID_VALUE);
 429
 430     ALCcontext_DecRef(Context);
 431 }
 432
 433
 434 AL_API void AL_APIENTRY alGetListener3i(ALenum eParam, ALint *plValue1, ALint *plValue2, ALint *plValue3)
 435 {
 436     ALCcontext *Context;
 437
 438     Context = GetContextRef();
 439     if(!Context) return;
 440
 441     if(plValue1 && plValue2 && plValue3)
 442     {
 443         switch (eParam)
 444         {
 445             case AL_POSITION:
 446                 LockContext(Context);
 447                 *plValue1 = (ALint)Context->Listener.Position[0];
 448                 *plValue2 = (ALint)Context->Listener.Position[1];
 449                 *plValue3 = (ALint)Context->Listener.Position[2];
 450                 UnlockContext(Context);
 451                 break;
 452
 453             case AL_VELOCITY:
 454                 LockContext(Context);
 455                 *plValue1 = (ALint)Context->Listener.Velocity[0];
 456                 *plValue2 = (ALint)Context->Listener.Velocity[1];
 457                 *plValue3 = (ALint)Context->Listener.Velocity[2];
 458                 UnlockContext(Context);
 459                 break;
 460
 461             default:
 462                 alSetError(Context, AL_INVALID_ENUM);
 463                 break;
 464         }
 465     }
 466     else
 467         alSetError(Context, AL_INVALID_VALUE);
 468
 469     ALCcontext_DecRef(Context);
 470 }
 471
 472
 473 AL_API void AL_APIENTRY alGetListeneriv(ALenum eParam, ALint* plValues)
 474 {
 475     ALCcontext *Context;
 476
 477     switch(eParam)
 478     {
 479         case AL_POSITION:
 480         case AL_VELOCITY:
 481             alGetListener3i(eParam, plValues+0, plValues+1, plValues+2);
 482             return;
 483     }
 484
 485     Context = GetContextRef();
 486     if(!Context) return;
 487
 488     if(plValues)
 489     {
 490         switch(eParam)
 491         {
 492             case AL_ORIENTATION:
 493                 LockContext(Context);
 494                 // AT then UP
 495                 plValues[0] = (ALint)Context->Listener.Forward[0];
 496                 plValues[1] = (ALint)Context->Listener.Forward[1];
 497                 plValues[2] = (ALint)Context->Listener.Forward[2];
 498                 plValues[3] = (ALint)Context->Listener.Up[0];
 499                 plValues[4] = (ALint)Context->Listener.Up[1];
 500                 plValues[5] = (ALint)Context->Listener.Up[2];
 501                 UnlockContext(Context);
 502                 break;
 503
 504             default:
 505                 alSetError(Context, AL_INVALID_ENUM);
 506                 break;
 507         }
 508     }
 509     else
 510         alSetError(Context, AL_INVALID_VALUE);
 511
 512     ALCcontext_DecRef(Context);
 513 }