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