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