OpenAL32/alBuffer.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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <assert.h>
  26 #include <limits.h>
  27 #ifdef HAVE_MALLOC_H
  28 #include <malloc.h>
  29 #endif
  30
  31 #include "alMain.h"
  32 #include "alu.h"
  33 #include "alError.h"
  34 #include "alBuffer.h"
  35 #include "alThunk.h"
  36 #include "sample_cvt.h"
  37
  38
  39 extern inline void LockBuffersRead(ALCdevice *device);
  40 extern inline void UnlockBuffersRead(ALCdevice *device);
  41 extern inline void LockBuffersWrite(ALCdevice *device);
  42 extern inline void UnlockBuffersWrite(ALCdevice *device);
  43 extern inline struct ALbuffer *LookupBuffer(ALCdevice *device, ALuint id);
  44 extern inline struct ALbuffer *RemoveBuffer(ALCdevice *device, ALuint id);
  45 extern inline ALsizei FrameSizeFromUserFmt(enum UserFmtChannels chans, enum UserFmtType type);
  46 extern inline ALsizei FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type);
  47
  48 static ALenum LoadData(ALbuffer *buffer, ALuint freq, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access);
  49 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, enum UserFmtType *type);
  50 static ALsizei SanitizeAlignment(enum UserFmtType type, ALsizei align);
  51
  52
  53 #define FORMAT_MASK  0x00ffffff
  54 #define CONSTRUCT_FLAGS (AL_MAP_READ_BIT_SOFT | AL_MAP_WRITE_BIT_SOFT | AL_PRESERVE_DATA_BIT_SOFT)
  55 #define INVALID_FORMAT_MASK  ~(FORMAT_MASK | CONSTRUCT_FLAGS)
  56 #define MAP_ACCESS_FLAGS (AL_MAP_READ_BIT_SOFT | AL_MAP_WRITE_BIT_SOFT)
  57
  58
  59 AL_API ALvoid AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
  60 {
  61     ALCcontext *context;
  62     ALsizei cur = 0;
  63
  64     context = GetContextRef();
  65     if(!context) return;
  66
  67     if(!(n >= 0))
  68         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  69
  70     for(cur = 0;cur < n;cur++)
  71     {
  72         ALbuffer *buffer = NewBuffer(context);
  73         if(!buffer)
  74         {
  75             alDeleteBuffers(cur, buffers);
  76             break;
  77         }
  78
  79         buffers[cur] = buffer->id;
  80     }
  81
  82 done:
  83     ALCcontext_DecRef(context);
  84 }
  85
  86 AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
  87 {
  88     ALCdevice *device;
  89     ALCcontext *context;
  90     ALbuffer *ALBuf;
  91     ALsizei i;
  92
  93     context = GetContextRef();
  94     if(!context) return;
  95
  96     device = context->Device;
  97
  98     LockBuffersWrite(device);
  99     if(!(n >= 0))
 100         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 101
 102     for(i = 0;i < n;i++)
 103     {
 104         if(!buffers[i])
 105             continue;
 106
 107         /* Check for valid Buffer ID */
 108         if((ALBuf=LookupBuffer(device, buffers[i])) == NULL)
 109             SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 110         if(ReadRef(&ALBuf->ref) != 0)
 111             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 112     }
 113
 114     for(i = 0;i < n;i++)
 115     {
 116         if((ALBuf=LookupBuffer(device, buffers[i])) != NULL)
 117             DeleteBuffer(device, ALBuf);
 118     }
 119
 120 done:
 121     UnlockBuffersWrite(device);
 122     ALCcontext_DecRef(context);
 123 }
 124
 125 AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer)
 126 {
 127     ALCcontext *context;
 128     ALboolean ret;
 129
 130     context = GetContextRef();
 131     if(!context) return AL_FALSE;
 132
 133     LockBuffersRead(context->Device);
 134     ret = ((!buffer || LookupBuffer(context->Device, buffer)) ?
 135            AL_TRUE : AL_FALSE);
 136     UnlockBuffersRead(context->Device);
 137
 138     ALCcontext_DecRef(context);
 139
 140     return ret;
 141 }
 142
 143
 144 AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq)
 145 {
 146     enum UserFmtChannels srcchannels = UserFmtMono;
 147     enum UserFmtType srctype = UserFmtUByte;
 148     ALCdevice *device;
 149     ALCcontext *context;
 150     ALbuffer *albuf;
 151     ALsizei framesize;
 152     ALsizei align;
 153     ALenum err;
 154
 155     context = GetContextRef();
 156     if(!context) return;
 157
 158     device = context->Device;
 159     LockBuffersRead(device);
 160     if((albuf=LookupBuffer(device, buffer)) == NULL)
 161         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 162     if(!(size >= 0 && freq > 0) || (format&INVALID_FORMAT_MASK) != 0)
 163         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 164     if(DecomposeUserFormat(format&FORMAT_MASK, &srcchannels, &srctype) == AL_FALSE)
 165         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 166
 167     align = SanitizeAlignment(srctype, ATOMIC_LOAD_SEQ(&albuf->UnpackAlign));
 168     if(align < 1) SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 169
 170     switch(srctype)
 171     {
 172         case UserFmtUByte:
 173         case UserFmtShort:
 174         case UserFmtFloat:
 175         case UserFmtDouble:
 176         case UserFmtMulaw:
 177         case UserFmtAlaw:
 178             framesize = FrameSizeFromUserFmt(srcchannels, srctype) * align;
 179             if((size%framesize) != 0)
 180                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 181
 182             err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
 183                            data, align, format&CONSTRUCT_FLAGS);
 184             if(err != AL_NO_ERROR)
 185                 SET_ERROR_AND_GOTO(context, err, done);
 186             break;
 187
 188         case UserFmtIMA4:
 189             framesize = ((align-1)/2 + 4) * ChannelsFromUserFmt(srcchannels);
 190             if((size%framesize) != 0)
 191                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 192
 193             err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
 194                            data, align, format&CONSTRUCT_FLAGS);
 195             if(err != AL_NO_ERROR)
 196                 SET_ERROR_AND_GOTO(context, err, done);
 197             break;
 198
 199         case UserFmtMSADPCM:
 200             framesize = ((align-2)/2 + 7) * ChannelsFromUserFmt(srcchannels);
 201             if((size%framesize) != 0)
 202                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 203
 204             err = LoadData(albuf, freq, size/framesize*align, srcchannels, srctype,
 205                            data, align, format&CONSTRUCT_FLAGS);
 206             if(err != AL_NO_ERROR)
 207                 SET_ERROR_AND_GOTO(context, err, done);
 208             break;
 209     }
 210
 211 done:
 212     UnlockBuffersRead(device);
 213     ALCcontext_DecRef(context);
 214 }
 215
 216 AL_API void* AL_APIENTRY alMapBufferSOFT(ALuint buffer, ALsizei offset, ALsizei length, ALbitfieldSOFT access)
 217 {
 218     void *retval = NULL;
 219     ALCdevice *device;
 220     ALCcontext *context;
 221     ALbuffer *albuf;
 222
 223     context = GetContextRef();
 224     if(!context) return retval;
 225
 226     device = context->Device;
 227     LockBuffersRead(device);
 228     if((albuf=LookupBuffer(device, buffer)) == NULL)
 229         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 230     if(!access || (access&~MAP_ACCESS_FLAGS) != 0)
 231         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 232
 233     WriteLock(&albuf->lock);
 234     if(((access&AL_MAP_READ_BIT_SOFT) && !(albuf->Access&AL_MAP_READ_BIT_SOFT)) ||
 235        ((access&AL_MAP_WRITE_BIT_SOFT) && !(albuf->Access&AL_MAP_WRITE_BIT_SOFT)))
 236         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, unlock_done);
 237     if(offset < 0 || offset >= albuf->OriginalSize ||
 238        length <= 0 || length > albuf->OriginalSize - offset)
 239         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, unlock_done);
 240     if(ReadRef(&albuf->ref) != 0 || albuf->MappedAccess != 0)
 241         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, unlock_done);
 242
 243     retval = (ALbyte*)albuf->data + offset;
 244     albuf->MappedAccess = access;
 245     if((access&AL_MAP_WRITE_BIT_SOFT) && !(access&AL_MAP_READ_BIT_SOFT))
 246         memset(retval, 0x55, length);
 247
 248 unlock_done:
 249     WriteUnlock(&albuf->lock);
 250
 251 done:
 252     UnlockBuffersRead(device);
 253     ALCcontext_DecRef(context);
 254
 255     return retval;
 256 }
 257
 258 AL_API void AL_APIENTRY alUnmapBufferSOFT(ALuint buffer)
 259 {
 260     ALCdevice *device;
 261     ALCcontext *context;
 262     ALbuffer *albuf;
 263
 264     context = GetContextRef();
 265     if(!context) return;
 266
 267     device = context->Device;
 268     LockBuffersRead(device);
 269     if((albuf=LookupBuffer(device, buffer)) == NULL)
 270         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 271
 272     WriteLock(&albuf->lock);
 273     if(albuf->MappedAccess == 0)
 274         alSetError(context, AL_INVALID_OPERATION);
 275     else
 276         albuf->MappedAccess = 0;
 277     WriteUnlock(&albuf->lock);
 278
 279 done:
 280     UnlockBuffersRead(device);
 281     ALCcontext_DecRef(context);
 282 }
 283
 284 AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length)
 285 {
 286     enum UserFmtChannels srcchannels = UserFmtMono;
 287     enum UserFmtType srctype = UserFmtUByte;
 288     ALCdevice *device;
 289     ALCcontext *context;
 290     ALbuffer *albuf;
 291     ALsizei byte_align;
 292     ALsizei frame_size;
 293     ALsizei num_chans;
 294     ALsizei align;
 295     void *dst;
 296
 297     context = GetContextRef();
 298     if(!context) return;
 299
 300     device = context->Device;
 301     LockBuffersRead(device);
 302     if((albuf=LookupBuffer(device, buffer)) == NULL)
 303         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 304     if(!(length >= 0 && offset >= 0))
 305         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 306     if(DecomposeUserFormat(format, &srcchannels, &srctype) == AL_FALSE)
 307         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 308     WriteLock(&albuf->lock);
 309     align = SanitizeAlignment(srctype, ATOMIC_LOAD_SEQ(&albuf->UnpackAlign));
 310     if(align < 1) SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, unlock_done);
 311
 312     if((long)srcchannels != (long)albuf->FmtChannels || srctype != albuf->OriginalType)
 313         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, unlock_done);
 314     if(align != albuf->OriginalAlign)
 315         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, unlock_done);
 316     if(albuf->MappedAccess != 0)
 317         SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, unlock_done);
 318
 319     num_chans = ChannelsFromFmt(albuf->FmtChannels);
 320     frame_size = num_chans * BytesFromFmt(albuf->FmtType);
 321     if(albuf->OriginalType == UserFmtIMA4)
 322         byte_align = ((align-1)/2 + 4) * num_chans;
 323     else if(albuf->OriginalType == UserFmtMSADPCM)
 324         byte_align = ((align-2)/2 + 7) * num_chans;
 325     else
 326         byte_align = align * frame_size;
 327
 328     if(offset > albuf->OriginalSize || length > albuf->OriginalSize-offset ||
 329        (offset%byte_align) != 0 || (length%byte_align) != 0)
 330         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, unlock_done);
 331
 332     /* offset -> byte offset, length -> sample count */
 333     offset = offset/byte_align * frame_size;
 334     length = length/byte_align * albuf->OriginalAlign;
 335
 336     dst = (ALbyte*)albuf->data + offset;
 337     if(srctype == UserFmtIMA4 && albuf->FmtType == FmtShort)
 338         Convert_ALshort_ALima4(dst, data, num_chans, length, align);
 339     else if(srctype == UserFmtMSADPCM && albuf->FmtType == FmtShort)
 340         Convert_ALshort_ALmsadpcm(dst, data, num_chans, length, align);
 341     else
 342     {
 343         assert((long)srctype == (long)albuf->FmtType);
 344         memcpy(dst, data, length*frame_size);
 345     }
 346
 347 unlock_done:
 348     WriteUnlock(&albuf->lock);
 349
 350 done:
 351     UnlockBuffersRead(device);
 352     ALCcontext_DecRef(context);
 353 }
 354
 355
 356 AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint UNUSED(buffer),
 357   ALuint UNUSED(samplerate), ALenum UNUSED(internalformat), ALsizei UNUSED(samples),
 358   ALenum UNUSED(channels), ALenum UNUSED(type), const ALvoid *UNUSED(data))
 359 {
 360     ALCcontext *context;
 361
 362     context = GetContextRef();
 363     if(!context) return;
 364
 365     alSetError(context, AL_INVALID_OPERATION);
 366
 367     ALCcontext_DecRef(context);
 368 }
 369
 370 AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint UNUSED(buffer),
 371   ALsizei UNUSED(offset), ALsizei UNUSED(samples),
 372   ALenum UNUSED(channels), ALenum UNUSED(type), const ALvoid *UNUSED(data))
 373 {
 374     ALCcontext *context;
 375
 376     context = GetContextRef();
 377     if(!context) return;
 378
 379     alSetError(context, AL_INVALID_OPERATION);
 380
 381     ALCcontext_DecRef(context);
 382 }
 383
 384 AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint UNUSED(buffer),
 385   ALsizei UNUSED(offset), ALsizei UNUSED(samples),
 386   ALenum UNUSED(channels), ALenum UNUSED(type), ALvoid *UNUSED(data))
 387 {
 388     ALCcontext *context;
 389
 390     context = GetContextRef();
 391     if(!context) return;
 392
 393     alSetError(context, AL_INVALID_OPERATION);
 394
 395     ALCcontext_DecRef(context);
 396 }
 397
 398 AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum UNUSED(format))
 399 {
 400     ALCcontext *context;
 401
 402     context = GetContextRef();
 403     if(!context) return AL_FALSE;
 404
 405     alSetError(context, AL_INVALID_OPERATION);
 406
 407     ALCcontext_DecRef(context);
 408     return AL_FALSE;
 409 }
 410
 411
 412 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat UNUSED(value))
 413 {
 414     ALCdevice *device;
 415     ALCcontext *context;
 416
 417     context = GetContextRef();
 418     if(!context) return;
 419
 420     device = context->Device;
 421     LockBuffersRead(device);
 422     if(LookupBuffer(device, buffer) == NULL)
 423         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 424
 425     switch(param)
 426     {
 427     default:
 428         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 429     }
 430
 431 done:
 432     UnlockBuffersRead(device);
 433     ALCcontext_DecRef(context);
 434 }
 435
 436
 437 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat UNUSED(value1), ALfloat UNUSED(value2), ALfloat UNUSED(value3))
 438 {
 439     ALCdevice *device;
 440     ALCcontext *context;
 441
 442     context = GetContextRef();
 443     if(!context) return;
 444
 445     device = context->Device;
 446     LockBuffersRead(device);
 447     if(LookupBuffer(device, buffer) == NULL)
 448         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 449
 450     switch(param)
 451     {
 452     default:
 453         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 454     }
 455
 456 done:
 457     UnlockBuffersRead(device);
 458     ALCcontext_DecRef(context);
 459 }
 460
 461
 462 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values)
 463 {
 464     ALCdevice *device;
 465     ALCcontext *context;
 466
 467     context = GetContextRef();
 468     if(!context) return;
 469
 470     device = context->Device;
 471     LockBuffersRead(device);
 472     if(LookupBuffer(device, buffer) == NULL)
 473         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 474
 475     if(!(values))
 476         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 477     switch(param)
 478     {
 479     default:
 480         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 481     }
 482
 483 done:
 484     UnlockBuffersRead(device);
 485     ALCcontext_DecRef(context);
 486 }
 487
 488
 489 AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value)
 490 {
 491     ALCdevice *device;
 492     ALCcontext *context;
 493     ALbuffer *albuf;
 494
 495     context = GetContextRef();
 496     if(!context) return;
 497
 498     device = context->Device;
 499     LockBuffersRead(device);
 500     if((albuf=LookupBuffer(device, buffer)) == NULL)
 501         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 502
 503     switch(param)
 504     {
 505     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 506         if(!(value >= 0))
 507             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 508         ATOMIC_STORE_SEQ(&albuf->UnpackAlign, value);
 509         break;
 510
 511     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 512         if(!(value >= 0))
 513             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 514         ATOMIC_STORE_SEQ(&albuf->PackAlign, value);
 515         break;
 516
 517     default:
 518         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 519     }
 520
 521 done:
 522     UnlockBuffersRead(device);
 523     ALCcontext_DecRef(context);
 524 }
 525
 526
 527 AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint UNUSED(value1), ALint UNUSED(value2), ALint UNUSED(value3))
 528 {
 529     ALCdevice *device;
 530     ALCcontext *context;
 531
 532     context = GetContextRef();
 533     if(!context) return;
 534
 535     device = context->Device;
 536     if(LookupBuffer(device, buffer) == NULL)
 537         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 538
 539     switch(param)
 540     {
 541     default:
 542         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 543     }
 544
 545 done:
 546     ALCcontext_DecRef(context);
 547 }
 548
 549
 550 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values)
 551 {
 552     ALCdevice *device;
 553     ALCcontext *context;
 554     ALbuffer *albuf;
 555
 556     if(values)
 557     {
 558         switch(param)
 559         {
 560             case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 561             case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 562                 alBufferi(buffer, param, values[0]);
 563                 return;
 564         }
 565     }
 566
 567     context = GetContextRef();
 568     if(!context) return;
 569
 570     device = context->Device;
 571     LockBuffersRead(device);
 572     if((albuf=LookupBuffer(device, buffer)) == NULL)
 573         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 574
 575     if(!(values))
 576         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 577     switch(param)
 578     {
 579     case AL_LOOP_POINTS_SOFT:
 580         WriteLock(&albuf->lock);
 581         if(ReadRef(&albuf->ref) != 0)
 582         {
 583             WriteUnlock(&albuf->lock);
 584             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 585         }
 586         if(values[0] >= values[1] || values[0] < 0 ||
 587            values[1] > albuf->SampleLen)
 588         {
 589             WriteUnlock(&albuf->lock);
 590             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 591         }
 592
 593         albuf->LoopStart = values[0];
 594         albuf->LoopEnd = values[1];
 595         WriteUnlock(&albuf->lock);
 596         break;
 597
 598     default:
 599         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 600     }
 601
 602 done:
 603     UnlockBuffersRead(device);
 604     ALCcontext_DecRef(context);
 605 }
 606
 607
 608 AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value)
 609 {
 610     ALCdevice *device;
 611     ALCcontext *context;
 612     ALbuffer *albuf;
 613
 614     context = GetContextRef();
 615     if(!context) return;
 616
 617     device = context->Device;
 618     LockBuffersRead(device);
 619     if((albuf=LookupBuffer(device, buffer)) == NULL)
 620         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 621
 622     if(!(value))
 623         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 624     switch(param)
 625     {
 626     default:
 627         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 628     }
 629
 630 done:
 631     UnlockBuffersRead(device);
 632     ALCcontext_DecRef(context);
 633 }
 634
 635
 636 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 637 {
 638     ALCdevice *device;
 639     ALCcontext *context;
 640
 641     context = GetContextRef();
 642     if(!context) return;
 643
 644     device = context->Device;
 645     LockBuffersRead(device);
 646     if(LookupBuffer(device, buffer) == NULL)
 647         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 648
 649     if(!(value1 && value2 && value3))
 650         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 651     switch(param)
 652     {
 653     default:
 654         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 655     }
 656
 657 done:
 658     UnlockBuffersRead(device);
 659     ALCcontext_DecRef(context);
 660 }
 661
 662
 663 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values)
 664 {
 665     ALCdevice *device;
 666     ALCcontext *context;
 667
 668     switch(param)
 669     {
 670     case AL_SEC_LENGTH_SOFT:
 671         alGetBufferf(buffer, param, values);
 672         return;
 673     }
 674
 675     context = GetContextRef();
 676     if(!context) return;
 677
 678     device = context->Device;
 679     LockBuffersRead(device);
 680     if(LookupBuffer(device, buffer) == NULL)
 681         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 682
 683     if(!(values))
 684         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 685     switch(param)
 686     {
 687     default:
 688         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 689     }
 690
 691 done:
 692     UnlockBuffersRead(device);
 693     ALCcontext_DecRef(context);
 694 }
 695
 696
 697 AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value)
 698 {
 699     ALCdevice *device;
 700     ALCcontext *context;
 701     ALbuffer *albuf;
 702
 703     context = GetContextRef();
 704     if(!context) return;
 705
 706     device = context->Device;
 707     LockBuffersRead(device);
 708     if((albuf=LookupBuffer(device, buffer)) == NULL)
 709         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 710
 711     if(!(value))
 712         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 713     switch(param)
 714     {
 715     case AL_FREQUENCY:
 716         *value = albuf->Frequency;
 717         break;
 718
 719     case AL_BITS:
 720         *value = BytesFromFmt(albuf->FmtType) * 8;
 721         break;
 722
 723     case AL_CHANNELS:
 724         *value = ChannelsFromFmt(albuf->FmtChannels);
 725         break;
 726
 727     case AL_SIZE:
 728         ReadLock(&albuf->lock);
 729         *value = albuf->SampleLen * FrameSizeFromFmt(albuf->FmtChannels,
 730                                                      albuf->FmtType);
 731         ReadUnlock(&albuf->lock);
 732         break;
 733
 734     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 735         *value = ATOMIC_LOAD_SEQ(&albuf->UnpackAlign);
 736         break;
 737
 738     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 739         *value = ATOMIC_LOAD_SEQ(&albuf->PackAlign);
 740         break;
 741
 742     default:
 743         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 744     }
 745
 746 done:
 747     UnlockBuffersRead(device);
 748     ALCcontext_DecRef(context);
 749 }
 750
 751
 752 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3)
 753 {
 754     ALCdevice *device;
 755     ALCcontext *context;
 756
 757     context = GetContextRef();
 758     if(!context) return;
 759
 760     device = context->Device;
 761     LockBuffersRead(device);
 762     if(LookupBuffer(device, buffer) == NULL)
 763         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 764
 765     if(!(value1 && value2 && value3))
 766         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 767     switch(param)
 768     {
 769     default:
 770         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 771     }
 772
 773 done:
 774     UnlockBuffersRead(device);
 775     ALCcontext_DecRef(context);
 776 }
 777
 778
 779 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values)
 780 {
 781     ALCdevice *device;
 782     ALCcontext *context;
 783     ALbuffer   *albuf;
 784
 785     switch(param)
 786     {
 787     case AL_FREQUENCY:
 788     case AL_BITS:
 789     case AL_CHANNELS:
 790     case AL_SIZE:
 791     case AL_INTERNAL_FORMAT_SOFT:
 792     case AL_BYTE_LENGTH_SOFT:
 793     case AL_SAMPLE_LENGTH_SOFT:
 794     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 795     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 796         alGetBufferi(buffer, param, values);
 797         return;
 798     }
 799
 800     context = GetContextRef();
 801     if(!context) return;
 802
 803     device = context->Device;
 804     LockBuffersRead(device);
 805     if((albuf=LookupBuffer(device, buffer)) == NULL)
 806         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 807
 808     if(!(values))
 809         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 810     switch(param)
 811     {
 812     case AL_LOOP_POINTS_SOFT:
 813         ReadLock(&albuf->lock);
 814         values[0] = albuf->LoopStart;
 815         values[1] = albuf->LoopEnd;
 816         ReadUnlock(&albuf->lock);
 817         break;
 818
 819     default:
 820         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 821     }
 822
 823 done:
 824     UnlockBuffersRead(device);
 825     ALCcontext_DecRef(context);
 826 }
 827
 828
 829 /*
 830  * LoadData
 831  *
 832  * Loads the specified data into the buffer, using the specified formats.
 833  * Currently, the new format must have the same channel configuration as the
 834  * original format.
 835  */
 836 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALbitfieldSOFT access)
 837 {
 838     enum FmtChannels DstChannels = FmtMono;
 839     enum FmtType DstType = FmtUByte;
 840     ALsizei NumChannels, FrameSize;
 841     ALsizei newsize;
 842
 843     /* Currently no channels need to be converted. */
 844     switch(SrcChannels)
 845     {
 846         case UserFmtMono: DstChannels = FmtMono; break;
 847         case UserFmtStereo: DstChannels = FmtStereo; break;
 848         case UserFmtRear: DstChannels = FmtRear; break;
 849         case UserFmtQuad: DstChannels = FmtQuad; break;
 850         case UserFmtX51: DstChannels = FmtX51; break;
 851         case UserFmtX61: DstChannels = FmtX61; break;
 852         case UserFmtX71: DstChannels = FmtX71; break;
 853         case UserFmtBFormat2D: DstChannels = FmtBFormat2D; break;
 854         case UserFmtBFormat3D: DstChannels = FmtBFormat3D; break;
 855     }
 856     if((long)SrcChannels != (long)DstChannels)
 857         return AL_INVALID_ENUM;
 858
 859     /* IMA4 and MSADPCM convert to 16-bit short. */
 860     switch(SrcType)
 861     {
 862         case UserFmtUByte: DstType = FmtUByte; break;
 863         case UserFmtShort: DstType = FmtShort; break;
 864         case UserFmtFloat: DstType = FmtFloat; break;
 865         case UserFmtDouble: DstType = FmtDouble; break;
 866         case UserFmtAlaw: DstType = FmtAlaw; break;
 867         case UserFmtMulaw: DstType = FmtMulaw; break;
 868         case UserFmtIMA4: DstType = FmtShort; break;
 869         case UserFmtMSADPCM: DstType = FmtShort; break;
 870     }
 871
 872     if(access != 0)
 873     {
 874         if((long)SrcType != (long)DstType)
 875             return AL_INVALID_VALUE;
 876     }
 877
 878     NumChannels = ChannelsFromFmt(DstChannels);
 879     FrameSize = NumChannels * BytesFromFmt(DstType);
 880
 881     if(frames > INT_MAX/FrameSize)
 882         return AL_OUT_OF_MEMORY;
 883     newsize = frames*FrameSize;
 884
 885     WriteLock(&ALBuf->lock);
 886     if(ReadRef(&ALBuf->ref) != 0 || ALBuf->MappedAccess != 0)
 887     {
 888         WriteUnlock(&ALBuf->lock);
 889         return AL_INVALID_OPERATION;
 890     }
 891
 892     if((access&AL_PRESERVE_DATA_BIT_SOFT))
 893     {
 894         /* Can only preserve data with the same format and alignment. */
 895         if(ALBuf->FmtChannels != DstChannels || ALBuf->OriginalType != SrcType ||
 896            ALBuf->OriginalAlign != align)
 897         {
 898             WriteUnlock(&ALBuf->lock);
 899             return AL_INVALID_VALUE;
 900         }
 901     }
 902
 903     /* Round up to the next 16-byte multiple. This could reallocate only when
 904      * increasing or the new size is less than half the current, but then the
 905      * buffer's AL_SIZE would not be very reliable for accounting buffer memory
 906      * usage, and reporting the real size could cause problems for apps that
 907      * use AL_SIZE to try to get the buffer's play length.
 908      */
 909     if(newsize <= INT_MAX-15)
 910         newsize = (newsize+15) & ~0xf;
 911     if(newsize != ALBuf->BytesAlloc)
 912     {
 913         void *temp = al_malloc(16, (size_t)newsize);
 914         if(!temp && newsize)
 915         {
 916             WriteUnlock(&ALBuf->lock);
 917             return AL_OUT_OF_MEMORY;
 918         }
 919         if((access&AL_PRESERVE_DATA_BIT_SOFT))
 920         {
 921             ALsizei tocopy = mini(newsize, ALBuf->BytesAlloc);
 922             if(tocopy > 0) memcpy(temp, ALBuf->data, tocopy);
 923         }
 924         al_free(ALBuf->data);
 925         ALBuf->data = temp;
 926         ALBuf->BytesAlloc = newsize;
 927     }
 928
 929     ALBuf->OriginalType = SrcType;
 930     if(SrcType == UserFmtIMA4)
 931     {
 932         ALsizei byte_align   = ((align-1)/2 + 4) * NumChannels;
 933         ALBuf->OriginalSize  = frames / align * byte_align;
 934         ALBuf->OriginalAlign = align;
 935         assert(DstType == FmtShort);
 936         if(data != NULL && ALBuf->data != NULL)
 937             Convert_ALshort_ALima4(ALBuf->data, data, NumChannels, frames, align);
 938     }
 939     else if(SrcType == UserFmtMSADPCM)
 940     {
 941         ALsizei byte_align   = ((align-2)/2 + 7) * NumChannels;
 942         ALBuf->OriginalSize  = frames / align * byte_align;
 943         ALBuf->OriginalAlign = align;
 944         assert(DstType == FmtShort);
 945         if(data != NULL && ALBuf->data != NULL)
 946             Convert_ALshort_ALmsadpcm(ALBuf->data, data, NumChannels, frames, align);
 947     }
 948     else
 949     {
 950         ALBuf->OriginalSize  = frames * FrameSize;
 951         ALBuf->OriginalAlign = 1;
 952         assert((long)SrcType == (long)DstType);
 953         if(data != NULL && ALBuf->data != NULL)
 954             memcpy(ALBuf->data, data, frames*FrameSize);
 955     }
 956
 957     ALBuf->Frequency = freq;
 958     ALBuf->FmtChannels = DstChannels;
 959     ALBuf->FmtType = DstType;
 960     ALBuf->Access = access;
 961
 962     ALBuf->SampleLen = frames;
 963     ALBuf->LoopStart = 0;
 964     ALBuf->LoopEnd = ALBuf->SampleLen;
 965
 966     WriteUnlock(&ALBuf->lock);
 967     return AL_NO_ERROR;
 968 }
 969
 970
 971 ALsizei BytesFromUserFmt(enum UserFmtType type)
 972 {
 973     switch(type)
 974     {
 975     case UserFmtUByte: return sizeof(ALubyte);
 976     case UserFmtShort: return sizeof(ALshort);
 977     case UserFmtFloat: return sizeof(ALfloat);
 978     case UserFmtDouble: return sizeof(ALdouble);
 979     case UserFmtMulaw: return sizeof(ALubyte);
 980     case UserFmtAlaw: return sizeof(ALubyte);
 981     case UserFmtIMA4: break; /* not handled here */
 982     case UserFmtMSADPCM: break; /* not handled here */
 983     }
 984     return 0;
 985 }
 986 ALsizei ChannelsFromUserFmt(enum UserFmtChannels chans)
 987 {
 988     switch(chans)
 989     {
 990     case UserFmtMono: return 1;
 991     case UserFmtStereo: return 2;
 992     case UserFmtRear: return 2;
 993     case UserFmtQuad: return 4;
 994     case UserFmtX51: return 6;
 995     case UserFmtX61: return 7;
 996     case UserFmtX71: return 8;
 997     case UserFmtBFormat2D: return 3;
 998     case UserFmtBFormat3D: return 4;
 999     }
1000     return 0;
1001 }
1002 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans,
1003                                      enum UserFmtType *type)
1004 {
1005     static const struct {
1006         ALenum format;
1007         enum UserFmtChannels channels;
1008         enum UserFmtType type;
1009     } list[] = {
1010         { AL_FORMAT_MONO8,             UserFmtMono, UserFmtUByte   },
1011         { AL_FORMAT_MONO16,            UserFmtMono, UserFmtShort   },
1012         { AL_FORMAT_MONO_FLOAT32,      UserFmtMono, UserFmtFloat   },
1013         { AL_FORMAT_MONO_DOUBLE_EXT,   UserFmtMono, UserFmtDouble  },
1014         { AL_FORMAT_MONO_IMA4,         UserFmtMono, UserFmtIMA4    },
1015         { AL_FORMAT_MONO_MSADPCM_SOFT, UserFmtMono, UserFmtMSADPCM },
1016         { AL_FORMAT_MONO_MULAW,        UserFmtMono, UserFmtMulaw   },
1017         { AL_FORMAT_MONO_ALAW_EXT,     UserFmtMono, UserFmtAlaw    },
1018
1019         { AL_FORMAT_STEREO8,             UserFmtStereo, UserFmtUByte   },
1020         { AL_FORMAT_STEREO16,            UserFmtStereo, UserFmtShort   },
1021         { AL_FORMAT_STEREO_FLOAT32,      UserFmtStereo, UserFmtFloat   },
1022         { AL_FORMAT_STEREO_DOUBLE_EXT,   UserFmtStereo, UserFmtDouble  },
1023         { AL_FORMAT_STEREO_IMA4,         UserFmtStereo, UserFmtIMA4    },
1024         { AL_FORMAT_STEREO_MSADPCM_SOFT, UserFmtStereo, UserFmtMSADPCM },
1025         { AL_FORMAT_STEREO_MULAW,        UserFmtStereo, UserFmtMulaw   },
1026         { AL_FORMAT_STEREO_ALAW_EXT,     UserFmtStereo, UserFmtAlaw    },
1027
1028         { AL_FORMAT_REAR8,      UserFmtRear, UserFmtUByte },
1029         { AL_FORMAT_REAR16,     UserFmtRear, UserFmtShort },
1030         { AL_FORMAT_REAR32,     UserFmtRear, UserFmtFloat },
1031         { AL_FORMAT_REAR_MULAW, UserFmtRear, UserFmtMulaw },
1032
1033         { AL_FORMAT_QUAD8_LOKI,  UserFmtQuad, UserFmtUByte },
1034         { AL_FORMAT_QUAD16_LOKI, UserFmtQuad, UserFmtShort },
1035
1036         { AL_FORMAT_QUAD8,      UserFmtQuad, UserFmtUByte },
1037         { AL_FORMAT_QUAD16,     UserFmtQuad, UserFmtShort },
1038         { AL_FORMAT_QUAD32,     UserFmtQuad, UserFmtFloat },
1039         { AL_FORMAT_QUAD_MULAW, UserFmtQuad, UserFmtMulaw },
1040
1041         { AL_FORMAT_51CHN8,      UserFmtX51, UserFmtUByte },
1042         { AL_FORMAT_51CHN16,     UserFmtX51, UserFmtShort },
1043         { AL_FORMAT_51CHN32,     UserFmtX51, UserFmtFloat },
1044         { AL_FORMAT_51CHN_MULAW, UserFmtX51, UserFmtMulaw },
1045
1046         { AL_FORMAT_61CHN8,      UserFmtX61, UserFmtUByte },
1047         { AL_FORMAT_61CHN16,     UserFmtX61, UserFmtShort },
1048         { AL_FORMAT_61CHN32,     UserFmtX61, UserFmtFloat },
1049         { AL_FORMAT_61CHN_MULAW, UserFmtX61, UserFmtMulaw },
1050
1051         { AL_FORMAT_71CHN8,      UserFmtX71, UserFmtUByte },
1052         { AL_FORMAT_71CHN16,     UserFmtX71, UserFmtShort },
1053         { AL_FORMAT_71CHN32,     UserFmtX71, UserFmtFloat },
1054         { AL_FORMAT_71CHN_MULAW, UserFmtX71, UserFmtMulaw },
1055
1056         { AL_FORMAT_BFORMAT2D_8,       UserFmtBFormat2D, UserFmtUByte },
1057         { AL_FORMAT_BFORMAT2D_16,      UserFmtBFormat2D, UserFmtShort },
1058         { AL_FORMAT_BFORMAT2D_FLOAT32, UserFmtBFormat2D, UserFmtFloat },
1059         { AL_FORMAT_BFORMAT2D_MULAW,   UserFmtBFormat2D, UserFmtMulaw },
1060
1061         { AL_FORMAT_BFORMAT3D_8,       UserFmtBFormat3D, UserFmtUByte },
1062         { AL_FORMAT_BFORMAT3D_16,      UserFmtBFormat3D, UserFmtShort },
1063         { AL_FORMAT_BFORMAT3D_FLOAT32, UserFmtBFormat3D, UserFmtFloat },
1064         { AL_FORMAT_BFORMAT3D_MULAW,   UserFmtBFormat3D, UserFmtMulaw },
1065     };
1066     ALuint i;
1067
1068     for(i = 0;i < COUNTOF(list);i++)
1069     {
1070         if(list[i].format == format)
1071         {
1072             *chans = list[i].channels;
1073             *type  = list[i].type;
1074             return AL_TRUE;
1075         }
1076     }
1077
1078     return AL_FALSE;
1079 }
1080
1081 ALsizei BytesFromFmt(enum FmtType type)
1082 {
1083     switch(type)
1084     {
1085     case FmtUByte: return sizeof(ALubyte);
1086     case FmtShort: return sizeof(ALshort);
1087     case FmtFloat: return sizeof(ALfloat);
1088     case FmtDouble: return sizeof(ALdouble);
1089     case FmtMulaw: return sizeof(ALubyte);
1090     case FmtAlaw: return sizeof(ALubyte);
1091     }
1092     return 0;
1093 }
1094 ALsizei ChannelsFromFmt(enum FmtChannels chans)
1095 {
1096     switch(chans)
1097     {
1098     case FmtMono: return 1;
1099     case FmtStereo: return 2;
1100     case FmtRear: return 2;
1101     case FmtQuad: return 4;
1102     case FmtX51: return 6;
1103     case FmtX61: return 7;
1104     case FmtX71: return 8;
1105     case FmtBFormat2D: return 3;
1106     case FmtBFormat3D: return 4;
1107     }
1108     return 0;
1109 }
1110
1111 static ALsizei SanitizeAlignment(enum UserFmtType type, ALsizei align)
1112 {
1113     if(align < 0)
1114         return 0;
1115
1116     if(align == 0)
1117     {
1118         if(type == UserFmtIMA4)
1119         {
1120             /* Here is where things vary:
1121              * nVidia and Apple use 64+1 sample frames per block -> block_size=36 bytes per channel
1122              * Most PC sound software uses 2040+1 sample frames per block -> block_size=1024 bytes per channel
1123              */
1124             return 65;
1125         }
1126         if(type == UserFmtMSADPCM)
1127             return 64;
1128         return 1;
1129     }
1130
1131     if(type == UserFmtIMA4)
1132     {
1133         /* IMA4 block alignment must be a multiple of 8, plus 1. */
1134         if((align&7) == 1) return align;
1135         return 0;
1136     }
1137     if(type == UserFmtMSADPCM)
1138     {
1139         /* MSADPCM block alignment must be a multiple of 2. */
1140         if((align&1) == 0) return align;
1141         return 0;
1142     }
1143
1144     return align;
1145 }
1146
1147
1148 ALbuffer *NewBuffer(ALCcontext *context)
1149 {
1150     ALCdevice *device = context->Device;
1151     ALbuffer *buffer;
1152     ALenum err;
1153
1154     buffer = al_calloc(16, sizeof(ALbuffer));
1155     if(!buffer)
1156         SET_ERROR_AND_RETURN_VALUE(context, AL_OUT_OF_MEMORY, NULL);
1157     RWLockInit(&buffer->lock);
1158     buffer->Access = 0;
1159     buffer->MappedAccess = 0;
1160
1161     err = NewThunkEntry(&buffer->id);
1162     if(err == AL_NO_ERROR)
1163         err = InsertUIntMapEntry(&device->BufferMap, buffer->id, buffer);
1164     if(err != AL_NO_ERROR)
1165     {
1166         FreeThunkEntry(buffer->id);
1167         memset(buffer, 0, sizeof(ALbuffer));
1168         al_free(buffer);
1169
1170         SET_ERROR_AND_RETURN_VALUE(context, err, NULL);
1171     }
1172
1173     return buffer;
1174 }
1175
1176 void DeleteBuffer(ALCdevice *device, ALbuffer *buffer)
1177 {
1178     RemoveBuffer(device, buffer->id);
1179     FreeThunkEntry(buffer->id);
1180
1181     al_free(buffer->data);
1182
1183     memset(buffer, 0, sizeof(*buffer));
1184     al_free(buffer);
1185 }
1186
1187
1188 /*
1189  *    ReleaseALBuffers()
1190  *
1191  *    INTERNAL: Called to destroy any buffers that still exist on the device
1192  */
1193 ALvoid ReleaseALBuffers(ALCdevice *device)
1194 {
1195     ALsizei i;
1196     for(i = 0;i < device->BufferMap.size;i++)
1197     {
1198         ALbuffer *temp = device->BufferMap.values[i];
1199         device->BufferMap.values[i] = NULL;
1200
1201         al_free(temp->data);
1202
1203         FreeThunkEntry(temp->id);
1204         memset(temp, 0, sizeof(ALbuffer));
1205         al_free(temp);
1206     }
1207 }