OpenAL32/alEffect.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 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 <stdlib.h>
  24
  25 #include "AL/al.h"
  26 #include "AL/alc.h"
  27 #include "alMain.h"
  28 #include "alEffect.h"
  29 #include "alThunk.h"
  30 #include "alError.h"
  31
  32
  33 ALboolean DisabledEffects[MAX_EFFECTS];
  34
  35
  36 static ALeffect *g_EffectList;
  37 static ALuint    g_EffectCount;
  38
  39 static void InitEffectParams(ALeffect *effect, ALenum type);
  40
  41
  42 ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
  43 {
  44     ALCcontext *Context;
  45     ALsizei i;
  46
  47     Context = alcGetCurrentContext();
  48     SuspendContext(Context);
  49
  50     if (n > 0)
  51     {
  52         // Check that enough memory has been allocted in the 'effects' array for n Effects
  53         if (!IsBadWritePtr((void*)effects, n * sizeof(ALuint)))
  54         {
  55             ALeffect **list = &g_EffectList;
  56             while(*list)
  57                 list = &(*list)->next;
  58
  59             i = 0;
  60             while(i < n)
  61             {
  62                 *list = calloc(1, sizeof(ALeffect));
  63                 if(!(*list))
  64                 {
  65                     // We must have run out or memory
  66                     alDeleteEffects(i, effects);
  67                     alSetError(AL_OUT_OF_MEMORY);
  68                     break;
  69                 }
  70
  71                 effects[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  72                 (*list)->effect = effects[i];
  73
  74                 InitEffectParams(*list, AL_EFFECT_NULL);
  75                 g_EffectCount++;
  76                 i++;
  77
  78                 list = &(*list)->next;
  79             }
  80         }
  81     }
  82
  83     ProcessContext(Context);
  84 }
  85
  86 ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
  87 {
  88     ALCcontext *Context;
  89     ALeffect *ALEffect;
  90     ALsizei i;
  91
  92     Context = alcGetCurrentContext();
  93     SuspendContext(Context);
  94
  95     if (n >= 0)
  96     {
  97         // Check that all effects are valid
  98         for (i = 0; i < n; i++)
  99         {
 100             if (!alIsEffect(effects[i]))
 101             {
 102                 alSetError(AL_INVALID_NAME);
 103                 break;
 104             }
 105         }
 106
 107         if (i == n)
 108         {
 109             // All effects are valid
 110             for (i = 0; i < n; i++)
 111             {
 112                 // Recheck that the effect is valid, because there could be duplicated names
 113                 if (effects[i] && alIsEffect(effects[i]))
 114                 {
 115                     ALeffect **list;
 116
 117                     ALEffect = ((ALeffect*)ALTHUNK_LOOKUPENTRY(effects[i]));
 118
 119                     // Remove Source from list of Sources
 120                     list = &g_EffectList;
 121                     while(*list && *list != ALEffect)
 122                          list = &(*list)->next;
 123
 124                     if(*list)
 125                         *list = (*list)->next;
 126                     ALTHUNK_REMOVEENTRY(ALEffect->effect);
 127
 128                     memset(ALEffect, 0, sizeof(ALeffect));
 129                     free(ALEffect);
 130
 131                     g_EffectCount--;
 132                 }
 133             }
 134         }
 135     }
 136     else
 137         alSetError(AL_INVALID_VALUE);
 138
 139     ProcessContext(Context);
 140 }
 141
 142 ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 143 {
 144     ALCcontext *Context;
 145     ALeffect **list;
 146
 147     Context = alcGetCurrentContext();
 148     SuspendContext(Context);
 149
 150     list = &g_EffectList;
 151     while(*list && (*list)->effect != effect)
 152         list = &(*list)->next;
 153
 154     ProcessContext(Context);
 155
 156     return ((*list || !effect) ? AL_TRUE : AL_FALSE);
 157 }
 158
 159 ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 160 {
 161     ALCcontext *Context;
 162
 163     Context = alcGetCurrentContext();
 164     SuspendContext(Context);
 165
 166     if (effect && alIsEffect(effect))
 167     {
 168         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 169
 170         if(param == AL_EFFECT_TYPE)
 171         {
 172             ALboolean isOk = (iValue == AL_EFFECT_NULL ||
 173                 (iValue == AL_EFFECT_EAXREVERB && !DisabledEffects[EAXREVERB]) ||
 174                 (iValue == AL_EFFECT_REVERB && !DisabledEffects[REVERB]) ||
 175                 (iValue == AL_EFFECT_ECHO && !DisabledEffects[ECHO]));
 176
 177             if(isOk)
 178                 InitEffectParams(ALEffect, iValue);
 179             else
 180                 alSetError(AL_INVALID_VALUE);
 181         }
 182         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 183         {
 184             switch(param)
 185             {
 186             case AL_EAXREVERB_DECAY_HFLIMIT:
 187                 if(iValue >= AL_EAXREVERB_MIN_DECAY_HFLIMIT &&
 188                    iValue <= AL_EAXREVERB_MAX_DECAY_HFLIMIT)
 189                     ALEffect->Reverb.DecayHFLimit = iValue;
 190                 else
 191                     alSetError(AL_INVALID_VALUE);
 192                 break;
 193
 194             default:
 195                 alSetError(AL_INVALID_ENUM);
 196                 break;
 197             }
 198         }
 199         else if(ALEffect->type == AL_EFFECT_REVERB)
 200         {
 201             switch(param)
 202             {
 203             case AL_REVERB_DECAY_HFLIMIT:
 204                 if(iValue >= AL_REVERB_MIN_DECAY_HFLIMIT &&
 205                    iValue <= AL_REVERB_MAX_DECAY_HFLIMIT)
 206                     ALEffect->Reverb.DecayHFLimit = iValue;
 207                 else
 208                     alSetError(AL_INVALID_VALUE);
 209                 break;
 210
 211             default:
 212                 alSetError(AL_INVALID_ENUM);
 213                 break;
 214             }
 215         }
 216         else if(ALEffect->type == AL_EFFECT_ECHO)
 217         {
 218             switch(param)
 219             {
 220             default:
 221                 alSetError(AL_INVALID_ENUM);
 222                 break;
 223             }
 224         }
 225         else
 226             alSetError(AL_INVALID_ENUM);
 227     }
 228     else
 229         alSetError(AL_INVALID_NAME);
 230
 231     ProcessContext(Context);
 232 }
 233
 234 ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 235 {
 236     ALCcontext *Context;
 237
 238     Context = alcGetCurrentContext();
 239     SuspendContext(Context);
 240
 241     if (effect && alIsEffect(effect))
 242     {
 243         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 244
 245         if(param == AL_EFFECT_TYPE)
 246         {
 247             alEffecti(effect, param, piValues[0]);
 248         }
 249         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 250         {
 251             switch(param)
 252             {
 253             case AL_EAXREVERB_DECAY_HFLIMIT:
 254                 alEffecti(effect, param, piValues[0]);
 255                 break;
 256
 257             default:
 258                 alSetError(AL_INVALID_ENUM);
 259                 break;
 260             }
 261         }
 262         else if(ALEffect->type == AL_EFFECT_REVERB)
 263         {
 264             switch(param)
 265             {
 266             case AL_REVERB_DECAY_HFLIMIT:
 267                 alEffecti(effect, param, piValues[0]);
 268                 break;
 269
 270             default:
 271                 alSetError(AL_INVALID_ENUM);
 272                 break;
 273             }
 274         }
 275         else if(ALEffect->type == AL_EFFECT_ECHO)
 276         {
 277             switch(param)
 278             {
 279             default:
 280                 alSetError(AL_INVALID_ENUM);
 281                 break;
 282             }
 283         }
 284         else
 285             alSetError(AL_INVALID_ENUM);
 286     }
 287     else
 288         alSetError(AL_INVALID_NAME);
 289
 290     ProcessContext(Context);
 291 }
 292
 293 ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 294 {
 295     ALCcontext *Context;
 296
 297     Context = alcGetCurrentContext();
 298     SuspendContext(Context);
 299
 300     if (effect && alIsEffect(effect))
 301     {
 302         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 303
 304         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 305         {
 306             switch(param)
 307             {
 308             case AL_EAXREVERB_DENSITY:
 309                 if(flValue >= AL_EAXREVERB_MIN_DENSITY &&
 310                    flValue <= AL_EAXREVERB_MAX_DENSITY)
 311                     ALEffect->Reverb.Density = flValue;
 312                 else
 313                     alSetError(AL_INVALID_VALUE);
 314                 break;
 315
 316             case AL_EAXREVERB_DIFFUSION:
 317                 if(flValue >= AL_EAXREVERB_MIN_DIFFUSION &&
 318                    flValue <= AL_EAXREVERB_MAX_DIFFUSION)
 319                     ALEffect->Reverb.Diffusion = flValue;
 320                 else
 321                     alSetError(AL_INVALID_VALUE);
 322                 break;
 323
 324             case AL_EAXREVERB_GAIN:
 325                 if(flValue >= AL_EAXREVERB_MIN_GAIN &&
 326                    flValue <= AL_EAXREVERB_MAX_GAIN)
 327                     ALEffect->Reverb.Gain = flValue;
 328                 else
 329                     alSetError(AL_INVALID_VALUE);
 330                 break;
 331
 332             case AL_EAXREVERB_GAINHF:
 333                 if(flValue >= AL_EAXREVERB_MIN_GAINHF &&
 334                    flValue <= AL_EAXREVERB_MAX_GAIN)
 335                     ALEffect->Reverb.GainHF = flValue;
 336                 else
 337                     alSetError(AL_INVALID_VALUE);
 338                 break;
 339
 340             case AL_EAXREVERB_GAINLF:
 341                 if(flValue >= AL_EAXREVERB_MIN_GAINLF &&
 342                    flValue <= AL_EAXREVERB_MAX_GAINLF)
 343                     ALEffect->Reverb.GainLF = flValue;
 344                 else
 345                     alSetError(AL_INVALID_VALUE);
 346                 break;
 347
 348             case AL_EAXREVERB_DECAY_TIME:
 349                 if(flValue >= AL_EAXREVERB_MIN_DECAY_TIME &&
 350                    flValue <= AL_EAXREVERB_MAX_DECAY_TIME)
 351                     ALEffect->Reverb.DecayTime = flValue;
 352                 else
 353                     alSetError(AL_INVALID_VALUE);
 354                 break;
 355
 356             case AL_EAXREVERB_DECAY_HFRATIO:
 357                 if(flValue >= AL_EAXREVERB_MIN_DECAY_HFRATIO &&
 358                    flValue <= AL_EAXREVERB_MAX_DECAY_HFRATIO)
 359                     ALEffect->Reverb.DecayHFRatio = flValue;
 360                 else
 361                     alSetError(AL_INVALID_VALUE);
 362                 break;
 363
 364             case AL_EAXREVERB_DECAY_LFRATIO:
 365                 if(flValue >= AL_EAXREVERB_MIN_DECAY_LFRATIO &&
 366                    flValue <= AL_EAXREVERB_MAX_DECAY_LFRATIO)
 367                     ALEffect->Reverb.DecayLFRatio = flValue;
 368                 else
 369                     alSetError(AL_INVALID_VALUE);
 370                 break;
 371
 372             case AL_EAXREVERB_REFLECTIONS_GAIN:
 373                 if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_GAIN &&
 374                    flValue <= AL_EAXREVERB_MAX_REFLECTIONS_GAIN)
 375                     ALEffect->Reverb.ReflectionsGain = flValue;
 376                 else
 377                     alSetError(AL_INVALID_VALUE);
 378                 break;
 379
 380             case AL_EAXREVERB_REFLECTIONS_DELAY:
 381                 if(flValue >= AL_EAXREVERB_MIN_REFLECTIONS_DELAY &&
 382                    flValue <= AL_EAXREVERB_MAX_REFLECTIONS_DELAY)
 383                     ALEffect->Reverb.ReflectionsDelay = flValue;
 384                 else
 385                     alSetError(AL_INVALID_VALUE);
 386                 break;
 387
 388             case AL_EAXREVERB_LATE_REVERB_GAIN:
 389                 if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_GAIN &&
 390                    flValue <= AL_EAXREVERB_MAX_LATE_REVERB_GAIN)
 391                     ALEffect->Reverb.LateReverbGain = flValue;
 392                 else
 393                     alSetError(AL_INVALID_VALUE);
 394                 break;
 395
 396             case AL_EAXREVERB_LATE_REVERB_DELAY:
 397                 if(flValue >= AL_EAXREVERB_MIN_LATE_REVERB_DELAY &&
 398                    flValue <= AL_EAXREVERB_MAX_LATE_REVERB_DELAY)
 399                     ALEffect->Reverb.LateReverbDelay = flValue;
 400                 else
 401                     alSetError(AL_INVALID_VALUE);
 402                 break;
 403
 404             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 405                 if(flValue >= AL_EAXREVERB_MIN_AIR_ABSORPTION_GAINHF &&
 406                    flValue <= AL_EAXREVERB_MAX_AIR_ABSORPTION_GAINHF)
 407                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
 408                 else
 409                     alSetError(AL_INVALID_VALUE);
 410                 break;
 411
 412             case AL_EAXREVERB_ECHO_TIME:
 413                 if(flValue >= AL_EAXREVERB_MIN_ECHO_TIME &&
 414                    flValue <= AL_EAXREVERB_MAX_ECHO_TIME)
 415                     ALEffect->Reverb.EchoTime = flValue;
 416                 else
 417                     alSetError(AL_INVALID_VALUE);
 418                 break;
 419
 420             case AL_EAXREVERB_ECHO_DEPTH:
 421                 if(flValue >= AL_EAXREVERB_MIN_ECHO_DEPTH &&
 422                    flValue <= AL_EAXREVERB_MAX_ECHO_DEPTH)
 423                     ALEffect->Reverb.EchoDepth = flValue;
 424                 else
 425                     alSetError(AL_INVALID_VALUE);
 426                 break;
 427
 428             case AL_EAXREVERB_MODULATION_TIME:
 429                 if(flValue >= AL_EAXREVERB_MIN_MODULATION_TIME &&
 430                    flValue <= AL_EAXREVERB_MAX_MODULATION_TIME)
 431                     ALEffect->Reverb.ModulationTime = flValue;
 432                 else
 433                     alSetError(AL_INVALID_VALUE);
 434                 break;
 435
 436             case AL_EAXREVERB_MODULATION_DEPTH:
 437                 if(flValue >= AL_EAXREVERB_MIN_MODULATION_DEPTH &&
 438                    flValue <= AL_EAXREVERB_MAX_MODULATION_DEPTH)
 439                     ALEffect->Reverb.ModulationDepth = flValue;
 440                 else
 441                     alSetError(AL_INVALID_VALUE);
 442                 break;
 443
 444             case AL_EAXREVERB_HFREFERENCE:
 445                 if(flValue >= AL_EAXREVERB_MIN_HFREFERENCE &&
 446                    flValue <= AL_EAXREVERB_MAX_HFREFERENCE)
 447                     ALEffect->Reverb.HFReference = flValue;
 448                 else
 449                     alSetError(AL_INVALID_VALUE);
 450                 break;
 451
 452             case AL_EAXREVERB_LFREFERENCE:
 453                 if(flValue >= AL_EAXREVERB_MIN_LFREFERENCE &&
 454                    flValue <= AL_EAXREVERB_MAX_LFREFERENCE)
 455                     ALEffect->Reverb.LFReference = flValue;
 456                 else
 457                     alSetError(AL_INVALID_VALUE);
 458                 break;
 459
 460             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 461                 if(flValue >= 0.0f && flValue <= 10.0f)
 462                     ALEffect->Reverb.RoomRolloffFactor = flValue;
 463                 else
 464                     alSetError(AL_INVALID_VALUE);
 465                 break;
 466
 467             default:
 468                 alSetError(AL_INVALID_ENUM);
 469                 break;
 470             }
 471         }
 472         else if(ALEffect->type == AL_EFFECT_REVERB)
 473         {
 474             switch(param)
 475             {
 476             case AL_REVERB_DENSITY:
 477                 if(flValue >= AL_REVERB_MIN_DENSITY &&
 478                    flValue <= AL_REVERB_MAX_DENSITY)
 479                     ALEffect->Reverb.Density = flValue;
 480                 else
 481                     alSetError(AL_INVALID_VALUE);
 482                 break;
 483
 484             case AL_REVERB_DIFFUSION:
 485                 if(flValue >= AL_REVERB_MIN_DIFFUSION &&
 486                    flValue <= AL_REVERB_MAX_DIFFUSION)
 487                     ALEffect->Reverb.Diffusion = flValue;
 488                 else
 489                     alSetError(AL_INVALID_VALUE);
 490                 break;
 491
 492             case AL_REVERB_GAIN:
 493                 if(flValue >= AL_REVERB_MIN_GAIN &&
 494                    flValue <= AL_REVERB_MAX_GAIN)
 495                     ALEffect->Reverb.Gain = flValue;
 496                 else
 497                     alSetError(AL_INVALID_VALUE);
 498                 break;
 499
 500             case AL_REVERB_GAINHF:
 501                 if(flValue >= AL_REVERB_MIN_GAINHF &&
 502                    flValue <= AL_REVERB_MAX_GAINHF)
 503                     ALEffect->Reverb.GainHF = flValue;
 504                 else
 505                     alSetError(AL_INVALID_VALUE);
 506                 break;
 507
 508             case AL_REVERB_DECAY_TIME:
 509                 if(flValue >= AL_REVERB_MIN_DECAY_TIME &&
 510                    flValue <= AL_REVERB_MAX_DECAY_TIME)
 511                     ALEffect->Reverb.DecayTime = flValue;
 512                 else
 513                     alSetError(AL_INVALID_VALUE);
 514                 break;
 515
 516             case AL_REVERB_DECAY_HFRATIO:
 517                 if(flValue >= AL_REVERB_MIN_DECAY_HFRATIO &&
 518                    flValue <= AL_REVERB_MAX_DECAY_HFRATIO)
 519                     ALEffect->Reverb.DecayHFRatio = flValue;
 520                 else
 521                     alSetError(AL_INVALID_VALUE);
 522                 break;
 523
 524             case AL_REVERB_REFLECTIONS_GAIN:
 525                 if(flValue >= AL_REVERB_MIN_REFLECTIONS_GAIN &&
 526                    flValue <= AL_REVERB_MAX_REFLECTIONS_GAIN)
 527                     ALEffect->Reverb.ReflectionsGain = flValue;
 528                 else
 529                     alSetError(AL_INVALID_VALUE);
 530                 break;
 531
 532             case AL_REVERB_REFLECTIONS_DELAY:
 533                 if(flValue >= AL_REVERB_MIN_REFLECTIONS_DELAY &&
 534                    flValue <= AL_REVERB_MAX_REFLECTIONS_DELAY)
 535                     ALEffect->Reverb.ReflectionsDelay = flValue;
 536                 else
 537                     alSetError(AL_INVALID_VALUE);
 538                 break;
 539
 540             case AL_REVERB_LATE_REVERB_GAIN:
 541                 if(flValue >= AL_REVERB_MIN_LATE_REVERB_GAIN &&
 542                    flValue <= AL_REVERB_MAX_LATE_REVERB_GAIN)
 543                     ALEffect->Reverb.LateReverbGain = flValue;
 544                 else
 545                     alSetError(AL_INVALID_VALUE);
 546                 break;
 547
 548             case AL_REVERB_LATE_REVERB_DELAY:
 549                 if(flValue >= AL_REVERB_MIN_LATE_REVERB_DELAY &&
 550                    flValue <= AL_REVERB_MAX_LATE_REVERB_DELAY)
 551                     ALEffect->Reverb.LateReverbDelay = flValue;
 552                 else
 553                     alSetError(AL_INVALID_VALUE);
 554                 break;
 555
 556             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 557                 if(flValue >= AL_REVERB_MIN_AIR_ABSORPTION_GAINHF &&
 558                    flValue <= AL_REVERB_MAX_AIR_ABSORPTION_GAINHF)
 559                     ALEffect->Reverb.AirAbsorptionGainHF = flValue;
 560                 else
 561                     alSetError(AL_INVALID_VALUE);
 562                 break;
 563
 564             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 565                 if(flValue >= AL_REVERB_MIN_ROOM_ROLLOFF_FACTOR &&
 566                    flValue <= AL_REVERB_MAX_ROOM_ROLLOFF_FACTOR)
 567                     ALEffect->Reverb.RoomRolloffFactor = flValue;
 568                 else
 569                     alSetError(AL_INVALID_VALUE);
 570                 break;
 571
 572             default:
 573                 alSetError(AL_INVALID_ENUM);
 574                 break;
 575             }
 576         }
 577         else if(ALEffect->type == AL_EFFECT_ECHO)
 578         {
 579             switch(param)
 580             {
 581             case AL_ECHO_DELAY:
 582                 if(flValue >= AL_ECHO_MIN_DELAY && flValue <= AL_ECHO_MAX_DELAY)
 583                     ALEffect->Echo.Delay = flValue;
 584                 else
 585                     alSetError(AL_INVALID_VALUE);
 586                 break;
 587
 588             case AL_ECHO_LRDELAY:
 589                 if(flValue >= AL_ECHO_MIN_LRDELAY && flValue <= AL_ECHO_MAX_LRDELAY)
 590                     ALEffect->Echo.LRDelay = flValue;
 591                 else
 592                     alSetError(AL_INVALID_VALUE);
 593                 break;
 594
 595             case AL_ECHO_DAMPING:
 596                 if(flValue >= AL_ECHO_MIN_DAMPING && flValue <= AL_ECHO_MAX_DAMPING)
 597                     ALEffect->Echo.Damping = flValue;
 598                 else
 599                     alSetError(AL_INVALID_VALUE);
 600                 break;
 601
 602             case AL_ECHO_FEEDBACK:
 603                 if(flValue >= AL_ECHO_MIN_FEEDBACK && flValue <= AL_ECHO_MAX_FEEDBACK)
 604                     ALEffect->Echo.Feedback = flValue;
 605                 else
 606                     alSetError(AL_INVALID_VALUE);
 607                 break;
 608
 609             case AL_ECHO_SPREAD:
 610                 if(flValue >= AL_ECHO_MIN_SPREAD && flValue <= AL_ECHO_MAX_SPREAD)
 611                     ALEffect->Echo.Spread = flValue;
 612                 else
 613                     alSetError(AL_INVALID_VALUE);
 614                 break;
 615
 616             default:
 617                 alSetError(AL_INVALID_ENUM);
 618                 break;
 619             }
 620         }
 621         else
 622             alSetError(AL_INVALID_ENUM);
 623     }
 624     else
 625         alSetError(AL_INVALID_NAME);
 626
 627     ProcessContext(Context);
 628 }
 629
 630 ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 631 {
 632     ALCcontext *Context;
 633
 634     Context = alcGetCurrentContext();
 635     SuspendContext(Context);
 636
 637     if (effect && alIsEffect(effect))
 638     {
 639         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 640
 641         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 642         {
 643             switch(param)
 644             {
 645             case AL_EAXREVERB_DENSITY:
 646             case AL_EAXREVERB_DIFFUSION:
 647             case AL_EAXREVERB_GAIN:
 648             case AL_EAXREVERB_GAINHF:
 649             case AL_EAXREVERB_GAINLF:
 650             case AL_EAXREVERB_DECAY_TIME:
 651             case AL_EAXREVERB_DECAY_HFRATIO:
 652             case AL_EAXREVERB_DECAY_LFRATIO:
 653             case AL_EAXREVERB_REFLECTIONS_GAIN:
 654             case AL_EAXREVERB_REFLECTIONS_DELAY:
 655             case AL_EAXREVERB_LATE_REVERB_GAIN:
 656             case AL_EAXREVERB_LATE_REVERB_DELAY:
 657             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 658             case AL_EAXREVERB_ECHO_TIME:
 659             case AL_EAXREVERB_ECHO_DEPTH:
 660             case AL_EAXREVERB_MODULATION_TIME:
 661             case AL_EAXREVERB_MODULATION_DEPTH:
 662             case AL_EAXREVERB_HFREFERENCE:
 663             case AL_EAXREVERB_LFREFERENCE:
 664             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 665                 alEffectf(effect, param, pflValues[0]);
 666                 break;
 667
 668             case AL_EAXREVERB_REFLECTIONS_PAN:
 669                 ALEffect->Reverb.ReflectionsPan[0] = pflValues[0];
 670                 ALEffect->Reverb.ReflectionsPan[1] = pflValues[1];
 671                 ALEffect->Reverb.ReflectionsPan[2] = pflValues[2];
 672                 break;
 673             case AL_EAXREVERB_LATE_REVERB_PAN:
 674                 ALEffect->Reverb.LateReverbPan[0] = pflValues[0];
 675                 ALEffect->Reverb.LateReverbPan[1] = pflValues[1];
 676                 ALEffect->Reverb.LateReverbPan[2] = pflValues[2];
 677                 break;
 678
 679             default:
 680                 alSetError(AL_INVALID_ENUM);
 681                 break;
 682             }
 683         }
 684         else if(ALEffect->type == AL_EFFECT_REVERB)
 685         {
 686             switch(param)
 687             {
 688             case AL_REVERB_DENSITY:
 689             case AL_REVERB_DIFFUSION:
 690             case AL_REVERB_GAIN:
 691             case AL_REVERB_GAINHF:
 692             case AL_REVERB_DECAY_TIME:
 693             case AL_REVERB_DECAY_HFRATIO:
 694             case AL_REVERB_REFLECTIONS_GAIN:
 695             case AL_REVERB_REFLECTIONS_DELAY:
 696             case AL_REVERB_LATE_REVERB_GAIN:
 697             case AL_REVERB_LATE_REVERB_DELAY:
 698             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 699             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
 700                 alEffectf(effect, param, pflValues[0]);
 701                 break;
 702
 703             default:
 704                 alSetError(AL_INVALID_ENUM);
 705                 break;
 706             }
 707         }
 708         else if(ALEffect->type == AL_EFFECT_ECHO)
 709         {
 710             switch(param)
 711             {
 712             case AL_ECHO_DELAY:
 713             case AL_ECHO_LRDELAY:
 714             case AL_ECHO_DAMPING:
 715             case AL_ECHO_FEEDBACK:
 716             case AL_ECHO_SPREAD:
 717                 alEffectf(effect, param, pflValues[0]);
 718                 break;
 719
 720             default:
 721                 alSetError(AL_INVALID_ENUM);
 722                 break;
 723             }
 724         }
 725         else
 726             alSetError(AL_INVALID_ENUM);
 727     }
 728     else
 729         alSetError(AL_INVALID_NAME);
 730
 731     ProcessContext(Context);
 732 }
 733
 734 ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 735 {
 736     ALCcontext *Context;
 737
 738     Context = alcGetCurrentContext();
 739     SuspendContext(Context);
 740
 741     if (effect && alIsEffect(effect))
 742     {
 743         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 744
 745         if(param == AL_EFFECT_TYPE)
 746         {
 747             *piValue = ALEffect->type;
 748         }
 749         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 750         {
 751             switch(param)
 752             {
 753             case AL_EAXREVERB_DECAY_HFLIMIT:
 754                 *piValue = ALEffect->Reverb.DecayHFLimit;
 755                 break;
 756
 757             default:
 758                 alSetError(AL_INVALID_ENUM);
 759                 break;
 760             }
 761         }
 762         else if(ALEffect->type == AL_EFFECT_REVERB)
 763         {
 764             switch(param)
 765             {
 766             case AL_REVERB_DECAY_HFLIMIT:
 767                 *piValue = ALEffect->Reverb.DecayHFLimit;
 768                 break;
 769
 770             default:
 771                 alSetError(AL_INVALID_ENUM);
 772                 break;
 773             }
 774         }
 775         else if(ALEffect->type == AL_EFFECT_ECHO)
 776         {
 777             switch(param)
 778             {
 779             default:
 780                 alSetError(AL_INVALID_ENUM);
 781                 break;
 782             }
 783         }
 784         else
 785             alSetError(AL_INVALID_ENUM);
 786     }
 787     else
 788         alSetError(AL_INVALID_NAME);
 789
 790     ProcessContext(Context);
 791 }
 792
 793 ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 794 {
 795     ALCcontext *Context;
 796
 797     Context = alcGetCurrentContext();
 798     SuspendContext(Context);
 799
 800     if (effect && alIsEffect(effect))
 801     {
 802         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 803
 804         if(param == AL_EFFECT_TYPE)
 805         {
 806             alGetEffecti(effect, param, piValues);
 807         }
 808         else if(ALEffect->type == AL_EFFECT_EAXREVERB)
 809         {
 810             switch(param)
 811             {
 812             case AL_EAXREVERB_DECAY_HFLIMIT:
 813                 alGetEffecti(effect, param, piValues);
 814                 break;
 815
 816             default:
 817                 alSetError(AL_INVALID_ENUM);
 818                 break;
 819             }
 820         }
 821         else if(ALEffect->type == AL_EFFECT_REVERB)
 822         {
 823             switch(param)
 824             {
 825             case AL_REVERB_DECAY_HFLIMIT:
 826                 alGetEffecti(effect, param, piValues);
 827                 break;
 828
 829             default:
 830                 alSetError(AL_INVALID_ENUM);
 831                 break;
 832             }
 833         }
 834         else if(ALEffect->type == AL_EFFECT_ECHO)
 835         {
 836             switch(param)
 837             {
 838             default:
 839                 alSetError(AL_INVALID_ENUM);
 840                 break;
 841             }
 842         }
 843         else
 844             alSetError(AL_INVALID_ENUM);
 845     }
 846     else
 847         alSetError(AL_INVALID_NAME);
 848
 849     ProcessContext(Context);
 850 }
 851
 852 ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 853 {
 854     ALCcontext *Context;
 855
 856     Context = alcGetCurrentContext();
 857     SuspendContext(Context);
 858
 859     if (effect && alIsEffect(effect))
 860     {
 861         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 862
 863         if(ALEffect->type == AL_EFFECT_EAXREVERB)
 864         {
 865             switch(param)
 866             {
 867             case AL_EAXREVERB_DENSITY:
 868                 *pflValue = ALEffect->Reverb.Density;
 869                 break;
 870
 871             case AL_EAXREVERB_DIFFUSION:
 872                 *pflValue = ALEffect->Reverb.Diffusion;
 873                 break;
 874
 875             case AL_EAXREVERB_GAIN:
 876                 *pflValue = ALEffect->Reverb.Gain;
 877                 break;
 878
 879             case AL_EAXREVERB_GAINHF:
 880                 *pflValue = ALEffect->Reverb.GainHF;
 881                 break;
 882
 883             case AL_EAXREVERB_GAINLF:
 884                 *pflValue = ALEffect->Reverb.GainLF;
 885                 break;
 886
 887             case AL_EAXREVERB_DECAY_TIME:
 888                 *pflValue = ALEffect->Reverb.DecayTime;
 889                 break;
 890
 891             case AL_EAXREVERB_DECAY_HFRATIO:
 892                 *pflValue = ALEffect->Reverb.DecayHFRatio;
 893                 break;
 894
 895             case AL_EAXREVERB_DECAY_LFRATIO:
 896                 *pflValue = ALEffect->Reverb.DecayLFRatio;
 897                 break;
 898
 899             case AL_EAXREVERB_REFLECTIONS_GAIN:
 900                 *pflValue = ALEffect->Reverb.ReflectionsGain;
 901                 break;
 902
 903             case AL_EAXREVERB_REFLECTIONS_DELAY:
 904                 *pflValue = ALEffect->Reverb.ReflectionsDelay;
 905                 break;
 906
 907             case AL_EAXREVERB_LATE_REVERB_GAIN:
 908                 *pflValue = ALEffect->Reverb.LateReverbGain;
 909                 break;
 910
 911             case AL_EAXREVERB_LATE_REVERB_DELAY:
 912                 *pflValue = ALEffect->Reverb.LateReverbDelay;
 913                 break;
 914
 915             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
 916                 *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
 917                 break;
 918
 919             case AL_EAXREVERB_ECHO_TIME:
 920                 *pflValue = ALEffect->Reverb.EchoTime;
 921                 break;
 922
 923             case AL_EAXREVERB_ECHO_DEPTH:
 924                 *pflValue = ALEffect->Reverb.EchoDepth;
 925                 break;
 926
 927             case AL_EAXREVERB_MODULATION_TIME:
 928                 *pflValue = ALEffect->Reverb.ModulationTime;
 929                 break;
 930
 931             case AL_EAXREVERB_MODULATION_DEPTH:
 932                 *pflValue = ALEffect->Reverb.ModulationDepth;
 933                 break;
 934
 935             case AL_EAXREVERB_HFREFERENCE:
 936                 *pflValue = ALEffect->Reverb.HFReference;
 937                 break;
 938
 939             case AL_EAXREVERB_LFREFERENCE:
 940                 *pflValue = ALEffect->Reverb.LFReference;
 941                 break;
 942
 943             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
 944                 *pflValue = ALEffect->Reverb.RoomRolloffFactor;
 945                 break;
 946
 947             default:
 948                 alSetError(AL_INVALID_ENUM);
 949                 break;
 950             }
 951         }
 952         else if(ALEffect->type == AL_EFFECT_REVERB)
 953         {
 954             switch(param)
 955             {
 956             case AL_REVERB_DENSITY:
 957                 *pflValue = ALEffect->Reverb.Density;
 958                 break;
 959
 960             case AL_REVERB_DIFFUSION:
 961                 *pflValue = ALEffect->Reverb.Diffusion;
 962                 break;
 963
 964             case AL_REVERB_GAIN:
 965                 *pflValue = ALEffect->Reverb.Gain;
 966                 break;
 967
 968             case AL_REVERB_GAINHF:
 969                 *pflValue = ALEffect->Reverb.GainHF;
 970                 break;
 971
 972             case AL_REVERB_DECAY_TIME:
 973                 *pflValue = ALEffect->Reverb.DecayTime;
 974                 break;
 975
 976             case AL_REVERB_DECAY_HFRATIO:
 977                 *pflValue = ALEffect->Reverb.DecayHFRatio;
 978                 break;
 979
 980             case AL_REVERB_REFLECTIONS_GAIN:
 981                 *pflValue = ALEffect->Reverb.ReflectionsGain;
 982                 break;
 983
 984             case AL_REVERB_REFLECTIONS_DELAY:
 985                 *pflValue = ALEffect->Reverb.ReflectionsDelay;
 986                 break;
 987
 988             case AL_REVERB_LATE_REVERB_GAIN:
 989                 *pflValue = ALEffect->Reverb.LateReverbGain;
 990                 break;
 991
 992             case AL_REVERB_LATE_REVERB_DELAY:
 993                 *pflValue = ALEffect->Reverb.LateReverbDelay;
 994                 break;
 995
 996             case AL_REVERB_AIR_ABSORPTION_GAINHF:
 997                 *pflValue = ALEffect->Reverb.AirAbsorptionGainHF;
 998                 break;
 999
1000             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
1001                 *pflValue = ALEffect->Reverb.RoomRolloffFactor;
1002                 break;
1003
1004             default:
1005                 alSetError(AL_INVALID_ENUM);
1006                 break;
1007             }
1008         }
1009         else if(ALEffect->type == AL_EFFECT_ECHO)
1010         {
1011             switch(param)
1012             {
1013             case AL_ECHO_DELAY:
1014                 *pflValue = ALEffect->Echo.Delay;
1015                 break;
1016
1017             case AL_ECHO_LRDELAY:
1018                 *pflValue = ALEffect->Echo.LRDelay;
1019                 break;
1020
1021             case AL_ECHO_DAMPING:
1022                 *pflValue = ALEffect->Echo.Damping;
1023                 break;
1024
1025             case AL_ECHO_FEEDBACK:
1026                 *pflValue = ALEffect->Echo.Feedback;
1027                 break;
1028
1029             case AL_ECHO_SPREAD:
1030                 *pflValue = ALEffect->Echo.Spread;
1031                 break;
1032
1033             default:
1034                 alSetError(AL_INVALID_ENUM);
1035                 break;
1036             }
1037         }
1038         else
1039             alSetError(AL_INVALID_ENUM);
1040     }
1041     else
1042         alSetError(AL_INVALID_NAME);
1043
1044     ProcessContext(Context);
1045 }
1046
1047 ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
1048 {
1049     ALCcontext *Context;
1050
1051     Context = alcGetCurrentContext();
1052     SuspendContext(Context);
1053
1054     if (effect && alIsEffect(effect))
1055     {
1056         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
1057
1058         if(ALEffect->type == AL_EFFECT_EAXREVERB)
1059         {
1060             switch(param)
1061             {
1062             case AL_EAXREVERB_DENSITY:
1063             case AL_EAXREVERB_DIFFUSION:
1064             case AL_EAXREVERB_GAIN:
1065             case AL_EAXREVERB_GAINHF:
1066             case AL_EAXREVERB_GAINLF:
1067             case AL_EAXREVERB_DECAY_TIME:
1068             case AL_EAXREVERB_DECAY_HFRATIO:
1069             case AL_EAXREVERB_DECAY_LFRATIO:
1070             case AL_EAXREVERB_REFLECTIONS_GAIN:
1071             case AL_EAXREVERB_REFLECTIONS_DELAY:
1072             case AL_EAXREVERB_LATE_REVERB_GAIN:
1073             case AL_EAXREVERB_LATE_REVERB_DELAY:
1074             case AL_EAXREVERB_AIR_ABSORPTION_GAINHF:
1075             case AL_EAXREVERB_ECHO_TIME:
1076             case AL_EAXREVERB_ECHO_DEPTH:
1077             case AL_EAXREVERB_MODULATION_TIME:
1078             case AL_EAXREVERB_MODULATION_DEPTH:
1079             case AL_EAXREVERB_HFREFERENCE:
1080             case AL_EAXREVERB_LFREFERENCE:
1081             case AL_EAXREVERB_ROOM_ROLLOFF_FACTOR:
1082                 alGetEffectf(effect, param, pflValues);
1083                 break;
1084
1085             case AL_EAXREVERB_REFLECTIONS_PAN:
1086                 pflValues[0] = ALEffect->Reverb.ReflectionsPan[0];
1087                 pflValues[1] = ALEffect->Reverb.ReflectionsPan[1];
1088                 pflValues[2] = ALEffect->Reverb.ReflectionsPan[2];
1089                 break;
1090             case AL_EAXREVERB_LATE_REVERB_PAN:
1091                 pflValues[0] = ALEffect->Reverb.LateReverbPan[0];
1092                 pflValues[1] = ALEffect->Reverb.LateReverbPan[1];
1093                 pflValues[2] = ALEffect->Reverb.LateReverbPan[2];
1094                 break;
1095
1096             default:
1097                 alSetError(AL_INVALID_ENUM);
1098                 break;
1099             }
1100         }
1101         else if(ALEffect->type == AL_EFFECT_REVERB)
1102         {
1103             switch(param)
1104             {
1105             case AL_REVERB_DENSITY:
1106             case AL_REVERB_DIFFUSION:
1107             case AL_REVERB_GAIN:
1108             case AL_REVERB_GAINHF:
1109             case AL_REVERB_DECAY_TIME:
1110             case AL_REVERB_DECAY_HFRATIO:
1111             case AL_REVERB_REFLECTIONS_GAIN:
1112             case AL_REVERB_REFLECTIONS_DELAY:
1113             case AL_REVERB_LATE_REVERB_GAIN:
1114             case AL_REVERB_LATE_REVERB_DELAY:
1115             case AL_REVERB_AIR_ABSORPTION_GAINHF:
1116             case AL_REVERB_ROOM_ROLLOFF_FACTOR:
1117                 alGetEffectf(effect, param, pflValues);
1118                 break;
1119
1120             default:
1121                 alSetError(AL_INVALID_ENUM);
1122                 break;
1123             }
1124         }
1125         else if(ALEffect->type == AL_EFFECT_ECHO)
1126         {
1127             switch(param)
1128             {
1129             case AL_ECHO_DELAY:
1130             case AL_ECHO_LRDELAY:
1131             case AL_ECHO_DAMPING:
1132             case AL_ECHO_FEEDBACK:
1133             case AL_ECHO_SPREAD:
1134                 alGetEffectf(effect, param, pflValues);
1135                 break;
1136
1137             default:
1138                 alSetError(AL_INVALID_ENUM);
1139                 break;
1140             }
1141         }
1142         else
1143             alSetError(AL_INVALID_ENUM);
1144     }
1145     else
1146         alSetError(AL_INVALID_NAME);
1147
1148     ProcessContext(Context);
1149 }
1150
1151
1152 ALvoid ReleaseALEffects(ALvoid)
1153 {
1154 #ifdef _DEBUG
1155     if(g_EffectCount > 0)
1156         AL_PRINT("exit(): deleting %d Effect(s)\n", g_EffectCount);
1157 #endif
1158
1159     while(g_EffectList)
1160     {
1161         ALeffect *temp = g_EffectList;
1162         g_EffectList = g_EffectList->next;
1163
1164         // Release effect structure
1165         memset(temp, 0, sizeof(ALeffect));
1166         free(temp);
1167     }
1168     g_EffectCount = 0;
1169 }
1170
1171
1172 static void InitEffectParams(ALeffect *effect, ALenum type)
1173 {
1174     effect->type = type;
1175     switch(type)
1176     {
1177     /* NOTE: Standard reverb and EAX reverb use the same defaults for the
1178      *       shared parameters, and EAX's additional parameters default to
1179      *       values assumed by standard reverb.
1180      */
1181     case AL_EFFECT_EAXREVERB:
1182     case AL_EFFECT_REVERB:
1183         effect->Reverb.Density = AL_EAXREVERB_DEFAULT_DENSITY;
1184         effect->Reverb.Diffusion = AL_EAXREVERB_DEFAULT_DIFFUSION;
1185         effect->Reverb.Gain = AL_EAXREVERB_DEFAULT_GAIN;
1186         effect->Reverb.GainHF = AL_EAXREVERB_DEFAULT_GAINHF;
1187         effect->Reverb.GainLF = AL_EAXREVERB_DEFAULT_GAINLF;
1188         effect->Reverb.DecayTime = AL_EAXREVERB_DEFAULT_DECAY_TIME;
1189         effect->Reverb.DecayHFRatio = AL_EAXREVERB_DEFAULT_DECAY_HFRATIO;
1190         effect->Reverb.DecayLFRatio = AL_EAXREVERB_DEFAULT_DECAY_LFRATIO;
1191         effect->Reverb.ReflectionsGain = AL_EAXREVERB_DEFAULT_REFLECTIONS_GAIN;
1192         effect->Reverb.ReflectionsDelay = AL_EAXREVERB_DEFAULT_REFLECTIONS_DELAY;
1193         effect->Reverb.ReflectionsPan[0] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1194         effect->Reverb.ReflectionsPan[1] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1195         effect->Reverb.ReflectionsPan[2] = AL_EAXREVERB_DEFAULT_REFLECTIONS_PAN_XYZ;
1196         effect->Reverb.LateReverbGain = AL_EAXREVERB_DEFAULT_LATE_REVERB_GAIN;
1197         effect->Reverb.LateReverbDelay = AL_EAXREVERB_DEFAULT_LATE_REVERB_DELAY;
1198         effect->Reverb.LateReverbPan[0] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1199         effect->Reverb.LateReverbPan[1] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1200         effect->Reverb.LateReverbPan[2] = AL_EAXREVERB_DEFAULT_LATE_REVERB_PAN_XYZ;
1201         effect->Reverb.EchoTime = AL_EAXREVERB_DEFAULT_ECHO_TIME;
1202         effect->Reverb.EchoDepth = AL_EAXREVERB_DEFAULT_ECHO_DEPTH;
1203         effect->Reverb.ModulationTime = AL_EAXREVERB_DEFAULT_MODULATION_TIME;
1204         effect->Reverb.ModulationDepth = AL_EAXREVERB_DEFAULT_MODULATION_DEPTH;
1205         effect->Reverb.AirAbsorptionGainHF = AL_EAXREVERB_DEFAULT_AIR_ABSORPTION_GAINHF;
1206         effect->Reverb.HFReference = AL_EAXREVERB_DEFAULT_HFREFERENCE;
1207         effect->Reverb.LFReference = AL_EAXREVERB_DEFAULT_LFREFERENCE;
1208         effect->Reverb.RoomRolloffFactor = AL_EAXREVERB_DEFAULT_ROOM_ROLLOFF_FACTOR;
1209         effect->Reverb.DecayHFLimit = AL_EAXREVERB_DEFAULT_DECAY_HFLIMIT;
1210         break;
1211     case AL_EFFECT_ECHO:
1212         effect->Echo.Delay = AL_ECHO_DEFAULT_DELAY;
1213         effect->Echo.LRDelay = AL_ECHO_DEFAULT_LRDELAY;
1214         effect->Echo.Damping = AL_ECHO_DEFAULT_DAMPING;
1215         effect->Echo.Feedback = AL_ECHO_DEFAULT_FEEDBACK;
1216         effect->Echo.Spread = AL_ECHO_DEFAULT_SPREAD;
1217         break;
1218     }
1219 }