OpenAL32/alDatabuffer.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 #include <stdio.h>
  25 #include <assert.h>
  26 #include "alMain.h"
  27 #include "AL/al.h"
  28 #include "AL/alc.h"
  29 #include "AL/alext.h"
  30 #include "alError.h"
  31 #include "alDatabuffer.h"
  32 #include "alThunk.h"
  33
  34
  35 DECL_VERIFIER(Databuffer, ALdatabuffer, databuffer)
  36
  37 /*
  38 *    alGenDatabuffersEXT(ALsizei n, ALuint *puiBuffers)
  39 *
  40 *    Generates n AL Databuffers, and stores the Databuffers Names in the array pointed to by puiBuffers
  41 */
  42 ALvoid ALAPIENTRY alGenDatabuffersEXT(ALsizei n,ALuint *puiBuffers)
  43 {
  44     ALCcontext *Context;
  45     ALsizei i=0;
  46
  47     Context = GetContextSuspended();
  48     if(!Context) return;
  49
  50     /* Check that we are actually generation some Databuffers */
  51     if(n > 0)
  52     {
  53         ALCdevice *device = Context->Device;
  54
  55         /* Check the pointer is valid (and points to enough memory to store
  56          * Databuffer Names) */
  57         if(!IsBadWritePtr((void*)puiBuffers, n * sizeof(ALuint)))
  58         {
  59             ALdatabuffer **list = &device->DatabufferList;
  60             while(*list)
  61                 list = &(*list)->next;
  62
  63             /* Create all the new Databuffers */
  64             while(i < n)
  65             {
  66                 *list = calloc(1, sizeof(ALdatabuffer));
  67                 if(!(*list))
  68                 {
  69                     alDeleteDatabuffersEXT(i, puiBuffers);
  70                     alSetError(Context, AL_OUT_OF_MEMORY);
  71                     break;
  72                 }
  73
  74                 puiBuffers[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  75                 (*list)->databuffer = puiBuffers[i];
  76                 (*list)->state = UNMAPPED;
  77                 device->DatabufferCount++;
  78                 i++;
  79
  80                 list = &(*list)->next;
  81             }
  82         }
  83         else
  84             alSetError(Context, AL_INVALID_VALUE);
  85     }
  86
  87     ProcessContext(Context);
  88 }
  89
  90 /*
  91 *    alDatabeleteBuffersEXT(ALsizei n, ALuint *puiBuffers)
  92 *
  93 *    Deletes the n AL Databuffers pointed to by puiBuffers
  94 */
  95 ALvoid ALAPIENTRY alDeleteDatabuffersEXT(ALsizei n, const ALuint *puiBuffers)
  96 {
  97     ALCcontext *Context;
  98     ALdatabuffer *ALBuf;
  99     ALsizei i;
 100     ALboolean bFailed = AL_FALSE;
 101
 102     Context = GetContextSuspended();
 103     if(!Context) return;
 104
 105     /* Check we are actually Deleting some Databuffers */
 106     if(n >= 0)
 107     {
 108         ALCdevice *device = Context->Device;
 109
 110         /* Check that all the databuffers are valid and can actually be
 111          * deleted */
 112         for(i = 0;i < n;i++)
 113         {
 114             if(!puiBuffers[i])
 115                 continue;
 116
 117             /* Check for valid Buffer ID */
 118             if((ALBuf=VerifyDatabuffer(device->DatabufferList, puiBuffers[i])) != NULL)
 119             {
 120                 if(ALBuf->state != UNMAPPED)
 121                 {
 122                     /* Databuffer still in use, cannot be deleted */
 123                     alSetError(Context, AL_INVALID_OPERATION);
 124                     bFailed = AL_TRUE;
 125                     break;
 126                 }
 127             }
 128             else
 129             {
 130                 /* Invalid Databuffer */
 131                 alSetError(Context, AL_INVALID_NAME);
 132                 bFailed = AL_TRUE;
 133                 break;
 134             }
 135         }
 136
 137         /* If all the Databuffers were valid (and unmapped), then we can
 138          * delete them */
 139         if(!bFailed)
 140         {
 141             for(i = 0;i < n;i++)
 142             {
 143                 if((ALBuf=VerifyDatabuffer(device->DatabufferList, puiBuffers[i])) != NULL)
 144                 {
 145                     ALdatabuffer **list = &device->DatabufferList;
 146
 147                     while(*list && *list != ALBuf)
 148                         list = &(*list)->next;
 149
 150                     if(*list)
 151                         *list = (*list)->next;
 152
 153                     if(ALBuf == Context->SampleSource)
 154                         Context->SampleSource = NULL;
 155                     if(ALBuf == Context->SampleSink)
 156                         Context->SampleSink = NULL;
 157
 158                     // Release the memory used to store audio data
 159                     free(ALBuf->data);
 160
 161                     // Release buffer structure
 162                     ALTHUNK_REMOVEENTRY(puiBuffers[i]);
 163                     memset(ALBuf, 0, sizeof(ALdatabuffer));
 164                     device->DatabufferCount--;
 165                     free(ALBuf);
 166                 }
 167             }
 168         }
 169     }
 170     else
 171         alSetError(Context, AL_INVALID_VALUE);
 172
 173     ProcessContext(Context);
 174 }
 175
 176 /*
 177 *    alIsDatabufferEXT(ALuint uiBuffer)
 178 *
 179 *    Checks if ulBuffer is a valid Databuffer Name
 180 */
 181 ALboolean ALAPIENTRY alIsDatabufferEXT(ALuint uiBuffer)
 182 {
 183     ALCcontext *Context;
 184     ALboolean  result = AL_TRUE;
 185     ALCdevice *device;
 186
 187     Context = GetContextSuspended();
 188     if(!Context) return AL_FALSE;
 189
 190     device = Context->Device;
 191     if(uiBuffer)
 192         result = (VerifyDatabuffer(device->DatabufferList, uiBuffer) ?
 193                   AL_TRUE : AL_FALSE);
 194
 195     ProcessContext(Context);
 196
 197     return result;
 198 }
 199
 200 /*
 201 *    alDatabufferDataEXT(ALuint buffer,ALvoid *data,ALsizei size,ALenum usage)
 202 *
 203 *    Fill databuffer with data
 204 */
 205 ALvoid ALAPIENTRY alDatabufferDataEXT(ALuint buffer,const ALvoid *data,ALsizeiptrEXT size,ALenum usage)
 206 {
 207     ALCcontext *Context;
 208     ALdatabuffer *ALBuf;
 209     ALCdevice *Device;
 210     ALvoid *temp;
 211
 212     Context = GetContextSuspended();
 213     if(!Context) return;
 214
 215     Device = Context->Device;
 216     if((ALBuf=VerifyDatabuffer(Device->DatabufferList, buffer)) != NULL)
 217     {
 218         if(ALBuf->state == UNMAPPED)
 219         {
 220             if(usage == AL_STREAM_WRITE_EXT || usage == AL_STREAM_READ_EXT ||
 221                usage == AL_STREAM_COPY_EXT || usage == AL_STATIC_WRITE_EXT ||
 222                usage == AL_STATIC_READ_EXT || usage == AL_STATIC_COPY_EXT ||
 223                usage == AL_DYNAMIC_WRITE_EXT || usage == AL_DYNAMIC_READ_EXT ||
 224                usage == AL_DYNAMIC_COPY_EXT)
 225             {
 226                 if(size >= 0)
 227                 {
 228                     /* (Re)allocate data */
 229                     temp = realloc(ALBuf->data, size);
 230                     if(temp)
 231                     {
 232                         ALBuf->data = temp;
 233                         ALBuf->size = size;
 234                         ALBuf->usage = usage;
 235                         if(data)
 236                             memcpy(ALBuf->data, data, size);
 237                     }
 238                     else
 239                         alSetError(Context, AL_OUT_OF_MEMORY);
 240                 }
 241                 else
 242                     alSetError(Context, AL_INVALID_VALUE);
 243             }
 244             else
 245                 alSetError(Context, AL_INVALID_ENUM);
 246         }
 247         else
 248             alSetError(Context, AL_INVALID_OPERATION);
 249     }
 250     else
 251         alSetError(Context, AL_INVALID_NAME);
 252
 253     ProcessContext(Context);
 254 }
 255
 256 ALvoid ALAPIENTRY alDatabufferSubDataEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, const ALvoid *data)
 257 {
 258     ALCcontext    *pContext;
 259     ALdatabuffer  *pBuffer;
 260     ALCdevice     *Device;
 261
 262     pContext = GetContextSuspended();
 263     if(!pContext) return;
 264
 265     Device = pContext->Device;
 266     if((pBuffer=VerifyDatabuffer(Device->DatabufferList, uiBuffer)) != NULL)
 267     {
 268         if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
 269         {
 270             if(pBuffer->state == UNMAPPED)
 271                 memcpy(pBuffer->data+start, data, length);
 272             else
 273                 alSetError(pContext, AL_INVALID_OPERATION);
 274         }
 275         else
 276             alSetError(pContext, AL_INVALID_VALUE);
 277     }
 278     else
 279         alSetError(pContext, AL_INVALID_NAME);
 280
 281     ProcessContext(pContext);
 282 }
 283
 284 ALvoid ALAPIENTRY alGetDatabufferSubDataEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALvoid *data)
 285 {
 286     ALCcontext    *pContext;
 287     ALdatabuffer  *pBuffer;
 288     ALCdevice     *Device;
 289
 290     pContext = GetContextSuspended();
 291     if(!pContext) return;
 292
 293     Device = pContext->Device;
 294     if((pBuffer=VerifyDatabuffer(Device->DatabufferList, uiBuffer)) != NULL)
 295     {
 296         if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
 297         {
 298             if(pBuffer->state == UNMAPPED)
 299                 memcpy(data, pBuffer->data+start, length);
 300             else
 301                 alSetError(pContext, AL_INVALID_OPERATION);
 302         }
 303         else
 304             alSetError(pContext, AL_INVALID_VALUE);
 305     }
 306     else
 307         alSetError(pContext, AL_INVALID_NAME);
 308
 309     ProcessContext(pContext);
 310 }
 311
 312
 313 ALvoid ALAPIENTRY alDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat flValue)
 314 {
 315     ALCcontext    *pContext;
 316     ALCdevice     *Device;
 317
 318     (void)flValue;
 319
 320     pContext = GetContextSuspended();
 321     if(!pContext) return;
 322
 323     Device = pContext->Device;
 324     if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 325     {
 326         switch(eParam)
 327         {
 328         default:
 329             alSetError(pContext, AL_INVALID_ENUM);
 330             break;
 331         }
 332     }
 333     else
 334         alSetError(pContext, AL_INVALID_NAME);
 335
 336     ProcessContext(pContext);
 337 }
 338
 339 ALvoid ALAPIENTRY alDatabufferfvEXT(ALuint buffer, ALenum eParam, const ALfloat* flValues)
 340 {
 341     ALCcontext    *pContext;
 342     ALCdevice     *Device;
 343
 344     (void)flValues;
 345
 346     pContext = GetContextSuspended();
 347     if(!pContext) return;
 348
 349     Device = pContext->Device;
 350     if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 351     {
 352         switch(eParam)
 353         {
 354         default:
 355             alSetError(pContext, AL_INVALID_ENUM);
 356             break;
 357         }
 358     }
 359     else
 360         alSetError(pContext, AL_INVALID_NAME);
 361
 362     ProcessContext(pContext);
 363 }
 364
 365
 366 ALvoid ALAPIENTRY alDatabufferiEXT(ALuint buffer, ALenum eParam, ALint lValue)
 367 {
 368     ALCcontext    *pContext;
 369     ALCdevice     *Device;
 370
 371     (void)lValue;
 372
 373     pContext = GetContextSuspended();
 374     if(!pContext) return;
 375
 376     Device = pContext->Device;
 377     if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 378     {
 379         switch(eParam)
 380         {
 381         default:
 382             alSetError(pContext, AL_INVALID_ENUM);
 383             break;
 384         }
 385     }
 386     else
 387         alSetError(pContext, AL_INVALID_NAME);
 388
 389     ProcessContext(pContext);
 390 }
 391
 392 ALvoid ALAPIENTRY alDatabufferivEXT(ALuint buffer, ALenum eParam, const ALint* plValues)
 393 {
 394     ALCcontext    *pContext;
 395     ALCdevice     *Device;
 396
 397     (void)plValues;
 398
 399     pContext = GetContextSuspended();
 400     if(!pContext) return;
 401
 402     Device = pContext->Device;
 403     if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 404     {
 405         switch(eParam)
 406         {
 407         default:
 408             alSetError(pContext, AL_INVALID_ENUM);
 409             break;
 410         }
 411     }
 412     else
 413         alSetError(pContext, AL_INVALID_NAME);
 414
 415     ProcessContext(pContext);
 416 }
 417
 418
 419 ALvoid ALAPIENTRY alGetDatabufferfEXT(ALuint buffer, ALenum eParam, ALfloat *pflValue)
 420 {
 421     ALCcontext    *pContext;
 422     ALCdevice     *Device;
 423
 424     pContext = GetContextSuspended();
 425     if(!pContext) return;
 426
 427     if(pflValue)
 428     {
 429         Device = pContext->Device;
 430         if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 431         {
 432             switch(eParam)
 433             {
 434             default:
 435                 alSetError(pContext, AL_INVALID_ENUM);
 436                 break;
 437             }
 438         }
 439         else
 440             alSetError(pContext, AL_INVALID_NAME);
 441     }
 442     else
 443         alSetError(pContext, AL_INVALID_VALUE);
 444
 445     ProcessContext(pContext);
 446 }
 447
 448 ALvoid ALAPIENTRY alGetDatabufferfvEXT(ALuint buffer, ALenum eParam, ALfloat* pflValues)
 449 {
 450     ALCcontext    *pContext;
 451     ALCdevice     *Device;
 452
 453     pContext = GetContextSuspended();
 454     if(!pContext) return;
 455
 456     if(pflValues)
 457     {
 458         Device = pContext->Device;
 459         if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 460         {
 461             switch(eParam)
 462             {
 463             default:
 464                 alSetError(pContext, AL_INVALID_ENUM);
 465                 break;
 466             }
 467         }
 468         else
 469             alSetError(pContext, AL_INVALID_NAME);
 470     }
 471     else
 472         alSetError(pContext, AL_INVALID_VALUE);
 473
 474     ProcessContext(pContext);
 475 }
 476
 477 ALvoid ALAPIENTRY alGetDatabufferiEXT(ALuint buffer, ALenum eParam, ALint *plValue)
 478 {
 479     ALCcontext    *pContext;
 480     ALdatabuffer  *pBuffer;
 481     ALCdevice     *Device;
 482
 483     pContext = GetContextSuspended();
 484     if(!pContext) return;
 485
 486     if(plValue)
 487     {
 488         Device = pContext->Device;
 489         if((pBuffer=VerifyDatabuffer(Device->DatabufferList, buffer)) != NULL)
 490         {
 491             switch(eParam)
 492             {
 493             case AL_SIZE:
 494                 *plValue = pBuffer->size;
 495                 break;
 496
 497             default:
 498                 alSetError(pContext, AL_INVALID_ENUM);
 499                 break;
 500             }
 501         }
 502         else
 503             alSetError(pContext, AL_INVALID_NAME);
 504     }
 505     else
 506         alSetError(pContext, AL_INVALID_VALUE);
 507
 508     ProcessContext(pContext);
 509 }
 510
 511 ALvoid ALAPIENTRY alGetDatabufferivEXT(ALuint buffer, ALenum eParam, ALint* plValues)
 512 {
 513     ALCcontext    *pContext;
 514     ALCdevice     *Device;
 515
 516     pContext = GetContextSuspended();
 517     if(!pContext) return;
 518
 519     if(plValues)
 520     {
 521         Device = pContext->Device;
 522         if(VerifyDatabuffer(Device->DatabufferList, buffer) != NULL)
 523         {
 524             switch (eParam)
 525             {
 526             case AL_SIZE:
 527                 alGetDatabufferiEXT(buffer, eParam, plValues);
 528                 break;
 529
 530             default:
 531                 alSetError(pContext, AL_INVALID_ENUM);
 532                 break;
 533             }
 534         }
 535         else
 536             alSetError(pContext, AL_INVALID_NAME);
 537     }
 538     else
 539         alSetError(pContext, AL_INVALID_VALUE);
 540
 541     ProcessContext(pContext);
 542 }
 543
 544
 545 ALvoid ALAPIENTRY alSelectDatabufferEXT(ALenum target, ALuint uiBuffer)
 546 {
 547     ALCcontext    *pContext;
 548     ALdatabuffer  *pBuffer = NULL;
 549     ALCdevice     *Device;
 550
 551     pContext = GetContextSuspended();
 552     if(!pContext) return;
 553
 554     Device = pContext->Device;
 555     if(uiBuffer == 0 ||
 556        (pBuffer=VerifyDatabuffer(Device->DatabufferList, uiBuffer)) != NULL)
 557     {
 558         if(target == AL_SAMPLE_SOURCE_EXT)
 559             pContext->SampleSource = pBuffer;
 560         else if(target == AL_SAMPLE_SINK_EXT)
 561             pContext->SampleSink = pBuffer;
 562         else
 563             alSetError(pContext, AL_INVALID_VALUE);
 564     }
 565     else
 566         alSetError(pContext, AL_INVALID_NAME);
 567
 568     ProcessContext(pContext);
 569 }
 570
 571
 572 ALvoid* ALAPIENTRY alMapDatabufferEXT(ALuint uiBuffer, ALintptrEXT start, ALsizeiptrEXT length, ALenum access)
 573 {
 574     ALCcontext    *pContext;
 575     ALdatabuffer  *pBuffer;
 576     ALvoid        *ret = NULL;
 577     ALCdevice     *Device;
 578
 579     pContext = GetContextSuspended();
 580     if(!pContext) return NULL;
 581
 582     Device = pContext->Device;
 583     if((pBuffer=VerifyDatabuffer(Device->DatabufferList, uiBuffer)) != NULL)
 584     {
 585         if(start >= 0 && length >= 0 && start+length <= pBuffer->size)
 586         {
 587             if(access == AL_READ_ONLY_EXT || access == AL_WRITE_ONLY_EXT ||
 588                access == AL_READ_WRITE_EXT)
 589             {
 590                 if(pBuffer->state == UNMAPPED)
 591                 {
 592                     ret = pBuffer->data + start;
 593                     pBuffer->state = MAPPED;
 594                 }
 595                 else
 596                     alSetError(pContext, AL_INVALID_OPERATION);
 597             }
 598             else
 599                 alSetError(pContext, AL_INVALID_ENUM);
 600         }
 601         else
 602             alSetError(pContext, AL_INVALID_VALUE);
 603     }
 604     else
 605         alSetError(pContext, AL_INVALID_NAME);
 606
 607     ProcessContext(pContext);
 608
 609     return ret;
 610 }
 611
 612 ALvoid ALAPIENTRY alUnmapDatabufferEXT(ALuint uiBuffer)
 613 {
 614     ALCcontext    *pContext;
 615     ALdatabuffer  *pBuffer;
 616     ALCdevice     *Device;
 617
 618     pContext = GetContextSuspended();
 619     if(!pContext) return;
 620
 621     Device = pContext->Device;
 622     if((pBuffer=VerifyDatabuffer(Device->DatabufferList, uiBuffer)) != NULL)
 623     {
 624         if(pBuffer->state == MAPPED)
 625             pBuffer->state = UNMAPPED;
 626         else
 627             alSetError(pContext, AL_INVALID_OPERATION);
 628     }
 629     else
 630         alSetError(pContext, AL_INVALID_NAME);
 631
 632     ProcessContext(pContext);
 633 }
 634
 635
 636 /*
 637 *    ReleaseALDatabuffers()
 638 *
 639 *    INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
 640 */
 641 ALvoid ReleaseALDatabuffers(ALCdevice *device)
 642 {
 643     ALdatabuffer *ALBuffer;
 644     ALdatabuffer *ALBufferTemp;
 645
 646     ALBuffer = device->DatabufferList;
 647     while(ALBuffer)
 648     {
 649         // Release sample data
 650         free(ALBuffer->data);
 651
 652         // Release Buffer structure
 653         ALBufferTemp = ALBuffer;
 654         ALBuffer = ALBuffer->next;
 655         memset(ALBufferTemp, 0, sizeof(ALdatabuffer));
 656         free(ALBufferTemp);
 657     }
 658     device->DatabufferList = NULL;
 659     device->DatabufferCount = 0;
 660 }