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