/libs/ObjectAL/OpenAL/ALWrapper.m
Objective C | 1397 lines | 1167 code | 169 blank | 61 comment | 37 complexity | 05f1ece03adfe2f6f2e70e2022ca598a MD5 | raw file
Possible License(s): Apache-2.0
1// 2// OpenAL.m 3// ObjectAL 4// 5// Created by Karl Stenerud on 15/12/09. 6// 7// Copyright 2009 Karl Stenerud 8// 9// Licensed under the Apache License, Version 2.0 (the "License"); 10// you may not use this file except in compliance with the License. 11// You may obtain a copy of the License at 12// 13// http://www.apache.org/licenses/LICENSE-2.0 14// 15// Unless required by applicable law or agreed to in writing, software 16// distributed under the License is distributed on an "AS IS" BASIS, 17// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 18// See the License for the specific language governing permissions and 19// limitations under the License. 20// 21// Note: You are NOT required to make the license available from within your 22// iOS application. Including it in your project is sufficient. 23// 24// Attribution is not required, but appreciated :) 25// 26 27#import "ALWrapper.h" 28#import "ObjectALMacros.h" 29#import "OALNotifications.h" 30 31/** Check the result of an AL call, logging an error if necessary. 32 * 33 * @return TRUE if the call was successful. 34 */ 35#define CHECK_AL_CALL() checkIfSuccessful(__PRETTY_FUNCTION__) 36 37/** Check the result of an ALC call, logging an error if necessary. 38 * 39 * @param DEVICE The device involved in the ALC call. 40 * @return TRUE if the call was successful. 41 */ 42#define CHECK_ALC_CALL(DEVICE) checkIfSuccessfulWithDevice(__PRETTY_FUNCTION__, (DEVICE)) 43 44 45/** 46 * Private interface to ALWrapper. 47 */ 48@interface ALWrapper (Private) 49 50/** Decode an OpenAL supplied NULL-separated string list into an NSArray. 51 * 52 * @param source the string list as supplied by OpenAL. 53 * @return the string list in an NSArray of NSString. 54 */ 55+ (NSArray*) decodeNullSeparatedStringList:(const ALCchar*) source; 56 57/** Decode an OpenAL supplied space-separated string list into an NSArray. 58 * 59 * @param source the string list as supplied by OpenAL. 60 * @return the string list in an NSArray of NSString. 61 */ 62+ (NSArray*) decodeSpaceSeparatedStringList:(const ALCchar*) source; 63 64/** Check the OpenAL error status and log an error message if necessary. 65 * 66 * @param contextInfo Contextual information to add when logging an error. 67 * @return TRUE if the operation was successful (no error). 68 */ 69BOOL checkIfSuccessful(const char* contextInfo); 70 71/** Check the OpenAL error status and log an error message if necessary. 72 * 73 * @param contextInfo Contextual information to add when logging an error. 74 * @param device The device to check for errors on. 75 * @return TRUE if the operation was successful (no error). 76 */ 77BOOL checkIfSuccessfulWithDevice(const char* contextInfo, ALCdevice* device); 78 79@end 80 81#pragma mark - 82 83@implementation ALWrapper 84 85typedef ALdouble AL_APIENTRY (*alcMacOSXGetMixerOutputRateProcPtr)(); 86typedef ALvoid AL_APIENTRY (*alcMacOSXMixerOutputRateProcPtr) (const ALdouble value); 87typedef ALvoid AL_APIENTRY (*alBufferDataStaticProcPtr) (const ALint bid, 88 ALenum format, 89 const ALvoid* data, 90 ALsizei size, 91 ALsizei freq); 92 93static alcMacOSXGetMixerOutputRateProcPtr alcGetMacOSXMixerOutputRate = NULL; 94static alcMacOSXMixerOutputRateProcPtr alcMacOSXMixerOutputRate = NULL; 95static alBufferDataStaticProcPtr alBufferDataStatic = NULL; 96 97 98#pragma mark - 99#pragma mark Error Handling 100 101BOOL checkIfSuccessful(const char* contextInfo) 102{ 103 ALenum error = alGetError(); 104 if(AL_NO_ERROR != error) 105 { 106 OAL_LOG_ERROR_CONTEXT(contextInfo, @"%s (error code 0x%08x)", alGetString(error), error); 107 [[NSNotificationCenter defaultCenter] postNotificationName:OALAudioErrorNotification object:[ALWrapper class]]; 108 return NO; 109 } 110 return YES; 111} 112 113BOOL checkIfSuccessfulWithDevice(const char* contextInfo, ALCdevice* device) 114{ 115 ALenum error = alcGetError(device); 116 if(ALC_NO_ERROR != error) 117 { 118 OAL_LOG_ERROR_CONTEXT(contextInfo, @"%s (error code 0x%08x)", alcGetString(device, error), error); 119 [[NSNotificationCenter defaultCenter] postNotificationName:OALAudioErrorNotification object:[ALWrapper class]]; 120 return NO; 121 } 122 return YES; 123} 124 125 126#pragma mark Internal Utility 127 128+ (NSArray*) decodeNullSeparatedStringList:(const ALCchar*) source 129{ 130 NSMutableArray* array = [NSMutableArray arrayWithCapacity:10]; 131 NSString* lastString = nil; 132 133 for(const ALCchar* nextString = source; 0 != *nextString; nextString += [lastString length] + 1) 134 { 135 lastString = [NSString stringWithFormat:@"%s", nextString]; 136 } 137 138 return array; 139} 140 141+ (NSArray*) decodeSpaceSeparatedStringList:(const ALCchar*) source 142{ 143 NSMutableArray* array = [NSMutableArray arrayWithCapacity:10]; 144 ALCchar buffer[200]; 145 ALCchar* bufferPtr = buffer; 146 const ALCchar* sourcePtr = source; 147 148 for(;;) 149 { 150 *bufferPtr = *sourcePtr; 151 if(' ' == *bufferPtr || bufferPtr >= buffer + 199) 152 { 153 *bufferPtr = 0; 154 } 155 if(0 == *bufferPtr) 156 { 157 [array addObject:[NSString stringWithFormat:@"%s", buffer]]; 158 bufferPtr = buffer; 159 } 160 else 161 { 162 bufferPtr++; 163 } 164 165 if(0 == *sourcePtr) 166 { 167 break; 168 } 169 170 sourcePtr++; 171 } 172 173 return array; 174} 175 176 177#pragma mark - 178#pragma mark OpenAL Management 179 180+ (bool) enable:(ALenum) capability 181{ 182 bool result; 183 @synchronized(self) 184 { 185 alEnable(capability); 186 result = CHECK_AL_CALL(); 187 } 188 return result; 189} 190 191+ (bool) disable:(ALenum) capability 192{ 193 bool result; 194 @synchronized(self) 195 { 196 alDisable(capability); 197 result = CHECK_AL_CALL(); 198 } 199 return result; 200} 201 202+ (bool) isEnabled:(ALenum) capability 203{ 204 ALboolean result; 205 @synchronized(self) 206 { 207 result = alIsEnabled(capability); 208 CHECK_AL_CALL(); 209 } 210 return result; 211} 212 213 214#pragma mark OpenAL Extensions 215 216+ (bool) isExtensionPresent:(NSString*) extensionName 217{ 218 ALboolean result; 219 @synchronized(self) 220 { 221 result = alIsExtensionPresent([extensionName UTF8String]); 222 CHECK_AL_CALL(); 223 } 224 return result; 225} 226 227+ (void*) getProcAddress:(NSString*) functionName 228{ 229 void* result; 230 @synchronized(self) 231 { 232 result = alGetProcAddress([functionName UTF8String]); 233 CHECK_AL_CALL(); 234 } 235 return result; 236} 237 238+ (ALenum) getEnumValue:(NSString*) enumName 239{ 240 ALenum result; 241 @synchronized(self) 242 { 243 result = alGetEnumValue([enumName UTF8String]); 244 CHECK_AL_CALL(); 245 } 246 return result; 247} 248 249 250#pragma mark - 251#pragma mark Device Management 252 253+ (ALCdevice*) openDevice:(NSString*) deviceName 254{ 255 ALCdevice* device; 256 @synchronized(self) 257 { 258 device = alcOpenDevice([deviceName UTF8String]); 259 if(NULL == device) 260 { 261 OAL_LOG_ERROR(@"Could not open device %@", deviceName); 262 } 263 } 264 return device; 265} 266 267+ (bool) closeDevice:(ALCdevice*) device 268{ 269 bool result; 270 @synchronized(self) 271 { 272 alcCloseDevice(device); 273 result = CHECK_ALC_CALL(device); 274 } 275 return result; 276} 277 278 279#pragma mark Device Extensions 280 281+ (bool) isExtensionPresent:(ALCdevice*) device name:(NSString*) extensionName 282{ 283 bool result; 284 @synchronized(self) 285 { 286 result = alcIsExtensionPresent(device, [extensionName UTF8String]); 287 CHECK_ALC_CALL(device); 288 } 289 return result; 290} 291 292+ (void*) getProcAddress:(ALCdevice*) device name:(NSString*) functionName 293{ 294 void* result; 295 @synchronized(self) 296 { 297 result = alcGetProcAddress(device, [functionName UTF8String]); 298 CHECK_ALC_CALL(device); 299 } 300 return result; 301} 302 303+ (ALenum) getEnumValue:(ALCdevice*) device name:(NSString*) enumName 304{ 305 ALenum result; 306 @synchronized(self) 307 { 308 result = alcGetEnumValue(device, [enumName UTF8String]); 309 CHECK_ALC_CALL(device); 310 } 311 return result; 312} 313 314 315#pragma mark Device Properties 316 317+ (NSString*) getString:(ALCdevice*) device attribute:(ALenum) attribute 318{ 319 const ALCchar* result; 320 @synchronized(self) 321 { 322 result = alcGetString(device, attribute); 323 CHECK_ALC_CALL(device); 324 } 325 return [NSString stringWithFormat:@"%s", result]; 326} 327 328+ (NSArray*) getNullSeparatedStringList:(ALCdevice*) device attribute:(ALenum) attribute 329{ 330 const ALCchar* result; 331 @synchronized(self) 332 { 333 result = alcGetString(device, attribute); 334 CHECK_ALC_CALL(device); 335 } 336 return [self decodeNullSeparatedStringList:result]; 337} 338 339+ (NSArray*) getSpaceSeparatedStringList:(ALCdevice*) device attribute:(ALenum) attribute 340{ 341 const ALCchar* result; 342 @synchronized(self) 343 { 344 result = alcGetString(device, attribute); 345 CHECK_ALC_CALL(device); 346 } 347 return [self decodeSpaceSeparatedStringList:result]; 348} 349 350+ (ALint) getInteger:(ALCdevice*) device attribute:(ALenum) attribute 351{ 352 ALint result = 0; 353 [self getIntegerv:device attribute:attribute size:1 data:&result]; 354 return result; 355} 356 357+ (bool) getIntegerv:(ALCdevice*) device attribute:(ALenum) attribute size:(ALsizei) size data:(ALCint*) data 358{ 359 bool result; 360 @synchronized(self) 361 { 362 alcGetIntegerv(device, attribute, size, data); 363 result = CHECK_ALC_CALL(device); 364 } 365 return result; 366} 367 368 369#pragma mark Capture 370 371+ (ALCdevice*) openCaptureDevice:(NSString*) deviceName frequency:(ALCuint) frequency format:(ALCenum) format bufferSize:(ALCsizei) bufferSize 372{ 373 ALCdevice* result; 374 @synchronized(self) 375 { 376 result = alcCaptureOpenDevice([deviceName UTF8String], frequency, format, bufferSize); 377 if(nil == result) 378 { 379 OAL_LOG_ERROR(@"Could not open capture device %@", deviceName); 380 } 381 } 382 return result; 383} 384 385+ (bool) closeCaptureDevice:(ALCdevice*) device 386{ 387 bool result; 388 @synchronized(self) 389 { 390 alcCaptureCloseDevice(device); 391 result = CHECK_ALC_CALL(device); 392 } 393 return result; 394} 395 396+ (bool) startCapture:(ALCdevice*) device 397{ 398 bool result; 399 @synchronized(self) 400 { 401 alcCaptureStop(device); 402 result = CHECK_ALC_CALL(device); 403 } 404 return result; 405} 406 407+ (bool) stopCapture:(ALCdevice*) device 408{ 409 bool result; 410 @synchronized(self) 411 { 412 alcCaptureStop(device); 413 result = CHECK_ALC_CALL(device); 414 } 415 return result; 416} 417 418+ (bool) captureSamples:(ALCdevice*) device buffer:(ALCvoid*) buffer numSamples:(ALCsizei) numSamples 419{ 420 bool result; 421 @synchronized(self) 422 { 423 alcCaptureSamples(device, buffer, numSamples); 424 result = CHECK_ALC_CALL(device); 425 } 426 return result; 427} 428 429 430#pragma mark - 431#pragma mark Context Management 432 433+ (ALCcontext*) createContext:(ALCdevice*) device attributes:(ALCint*) attributes 434{ 435 ALCcontext* result; 436 @synchronized(self) 437 { 438 result = alcCreateContext(device, attributes); 439 CHECK_ALC_CALL(device); 440 } 441 return result; 442} 443 444+ (bool) makeContextCurrent:(ALCcontext*) context 445{ 446 return [self makeContextCurrent:context deviceReference:nil]; 447} 448 449+ (bool) makeContextCurrent:(ALCcontext*) context deviceReference:(ALCdevice*) deviceReference 450{ 451 @synchronized(self) 452 { 453 if(!alcMakeContextCurrent(context)) 454 { 455 if(nil != deviceReference) 456 { 457 CHECK_ALC_CALL(deviceReference); 458 } 459 else 460 { 461 OAL_LOG_ERROR(@"Could not make context %d current. Pass in a device reference for better diagnostic info.", context); 462 } 463 return NO; 464 } 465 } 466 return YES; 467} 468 469+ (void) processContext:(ALCcontext*) context 470{ 471 @synchronized(self) 472 { 473 alcProcessContext(context); 474 // No way to check for error from here 475 } 476} 477 478+ (void) suspendContext:(ALCcontext*) context 479{ 480 @synchronized(self) 481 { 482 alcSuspendContext(context); 483 // No way to check for error from here 484 } 485} 486 487+ (void) destroyContext:(ALCcontext*) context 488{ 489 @synchronized(self) 490 { 491 alcDestroyContext(context); 492 // No way to check for error from here 493 } 494} 495 496+ (ALCcontext*) getCurrentContext 497{ 498 ALCcontext* result; 499 @synchronized(self) 500 { 501 result = alcGetCurrentContext(); 502 } 503 return result; 504} 505 506+ (ALCdevice*) getContextsDevice:(ALCcontext*) context 507{ 508 return [self getContextsDevice:context deviceReference:nil]; 509} 510 511+ (ALCdevice*) getContextsDevice:(ALCcontext*) context deviceReference:(ALCdevice*) deviceReference 512{ 513 ALCdevice* result; 514 @synchronized(self) 515 { 516 if(nil == (result = alcGetContextsDevice(context))) 517 { 518 if(nil != deviceReference) 519 { 520 CHECK_ALC_CALL(deviceReference); 521 } 522 else 523 { 524 OAL_LOG_ERROR(@"Could not get device for context %d. Pass in a device reference for better diagnostic info.", context); 525 } 526 } 527 } 528 return result; 529} 530 531 532#pragma mark Context Properties 533 534+ (bool) getBoolean:(ALenum) parameter 535{ 536 ALboolean result; 537 @synchronized(self) 538 { 539 result = alGetBoolean(parameter); 540 CHECK_AL_CALL(); 541 } 542 return result; 543} 544 545+ (ALdouble) getDouble:(ALenum) parameter 546{ 547 ALdouble result; 548 @synchronized(self) 549 { 550 result = alGetDouble(parameter); 551 CHECK_AL_CALL(); 552 } 553 return result; 554} 555 556+ (ALfloat) getFloat:(ALenum) parameter 557{ 558 ALfloat result; 559 @synchronized(self) 560 { 561 result = alGetFloat(parameter); 562 CHECK_AL_CALL(); 563 } 564 return result; 565} 566 567+ (ALint) getInteger:(ALenum) parameter 568{ 569 ALint result; 570 @synchronized(self) 571 { 572 result = alGetInteger(parameter); 573 CHECK_AL_CALL(); 574 } 575 return result; 576} 577 578+ (NSString*) getString:(ALenum) parameter 579{ 580 const ALchar* result; 581 @synchronized(self) 582 { 583 result = alGetString(parameter); 584 CHECK_AL_CALL(); 585 } 586 return [NSString stringWithFormat:@"%s", result]; 587} 588 589+ (NSArray*) getNullSeparatedStringList:(ALenum) parameter 590{ 591 const ALchar* result; 592 @synchronized(self) 593 { 594 result = alGetString(parameter); 595 CHECK_AL_CALL(); 596 } 597 return [self decodeNullSeparatedStringList:result]; 598} 599 600+ (NSArray*) getSpaceSeparatedStringList:(ALenum) parameter 601{ 602 const ALchar* result; 603 @synchronized(self) 604 { 605 result = alGetString(parameter); 606 CHECK_AL_CALL(); 607 } 608 return [self decodeSpaceSeparatedStringList:result]; 609} 610 611+ (bool) getBooleanv:(ALenum) parameter values:(ALboolean*) values 612{ 613 bool result; 614 @synchronized(self) 615 { 616 alGetBooleanv(parameter, values); 617 result = CHECK_AL_CALL(); 618 } 619 return result; 620} 621 622+ (bool) getDoublev:(ALenum) parameter values:(ALdouble*) values 623{ 624 bool result; 625 @synchronized(self) 626 { 627 alGetDoublev(parameter, values); 628 result = CHECK_AL_CALL(); 629 } 630 return result; 631} 632 633+ (bool) getFloatv:(ALenum) parameter values:(ALfloat*) values 634{ 635 bool result; 636 @synchronized(self) 637 { 638 alGetFloatv(parameter, values); 639 result = CHECK_AL_CALL(); 640 } 641 return result; 642} 643 644+ (bool) getIntegerv:(ALenum) parameter values:(ALint*) values 645{ 646 bool result; 647 @synchronized(self) 648 { 649 alGetIntegerv(parameter, values); 650 result = CHECK_AL_CALL(); 651 } 652 return result; 653} 654 655+ (bool) distanceModel:(ALenum) value 656{ 657 bool result; 658 @synchronized(self) 659 { 660 alDistanceModel(value); 661 result = CHECK_AL_CALL(); 662 } 663 return result; 664} 665 666+ (bool) dopplerFactor:(ALfloat) value 667{ 668 bool result; 669 @synchronized(self) 670 { 671 alDopplerFactor(value); 672 result = CHECK_AL_CALL(); 673 } 674 return result; 675} 676 677+ (bool) speedOfSound:(ALfloat) value 678{ 679 bool result; 680 @synchronized(self) 681 { 682 alSpeedOfSound(value); 683 result = CHECK_AL_CALL(); 684 } 685 return result; 686} 687 688 689#pragma mark - 690#pragma mark Listener Properties 691 692+ (bool) listenerf:(ALenum) parameter value:(ALfloat) value 693{ 694 bool result; 695 @synchronized(self) 696 { 697 alListenerf(parameter, value); 698 result = CHECK_AL_CALL(); 699 } 700 return result; 701} 702 703+ (bool) listener3f:(ALenum) parameter v1:(ALfloat) v1 v2:(ALfloat) v2 v3:(ALfloat) v3 704{ 705 bool result; 706 @synchronized(self) 707 { 708 alListener3f(parameter, v1, v2, v3); 709 result = CHECK_AL_CALL(); 710 } 711 return result; 712} 713 714+ (bool) listenerfv:(ALenum) parameter values:(ALfloat*) values 715{ 716 bool result; 717 @synchronized(self) 718 { 719 alListenerfv(parameter, values); 720 result = CHECK_AL_CALL(); 721 } 722 return result; 723} 724 725+ (bool) listeneri:(ALenum) parameter value:(ALint) value 726{ 727 bool result; 728 @synchronized(self) 729 { 730 alListeneri(parameter, value); 731 result = CHECK_AL_CALL(); 732 } 733 return result; 734} 735 736+ (bool) listener3i:(ALenum) parameter v1:(ALint) v1 v2:(ALint) v2 v3:(ALint) v3 737{ 738 bool result; 739 @synchronized(self) 740 { 741 alListener3i(parameter, v1, v2, v3); 742 result = CHECK_AL_CALL(); 743 } 744 return result; 745} 746 747+ (bool) listeneriv:(ALenum) parameter values:(ALint*) values 748{ 749 bool result; 750 @synchronized(self) 751 { 752 alListeneriv(parameter, values); 753 result = CHECK_AL_CALL(); 754 } 755 return result; 756} 757 758 759+ (ALfloat) getListenerf:(ALenum) parameter 760{ 761 ALfloat value; 762 @synchronized(self) 763 { 764 alGetListenerf(parameter, &value); 765 CHECK_AL_CALL(); 766 } 767 return value; 768} 769 770+ (bool) getListener3f:(ALenum) parameter v1:(ALfloat*) v1 v2:(ALfloat*) v2 v3:(ALfloat*) v3 771{ 772 bool result; 773 @synchronized(self) 774 { 775 alGetListener3f(parameter, v1, v2, v3); 776 result = CHECK_AL_CALL(); 777 } 778 return result; 779} 780 781+ (bool) getListenerfv:(ALenum) parameter values:(ALfloat*) values 782{ 783 bool result; 784 @synchronized(self) 785 { 786 alGetListenerfv(parameter, values); 787 result = CHECK_AL_CALL(); 788 } 789 return result; 790} 791 792+ (ALint) getListeneri:(ALenum) parameter 793{ 794 ALint value; 795 @synchronized(self) 796 { 797 alGetListeneri(parameter, &value); 798 CHECK_AL_CALL(); 799 } 800 return value; 801} 802 803+ (bool) getListener3i:(ALenum) parameter v1:(ALint*) v1 v2:(ALint*) v2 v3:(ALint*) v3 804{ 805 bool result; 806 @synchronized(self) 807 { 808 alGetListener3i(parameter, v1, v2, v3); 809 result = CHECK_AL_CALL(); 810 } 811 return result; 812} 813 814+ (bool) getListeneriv:(ALenum) parameter values:(ALint*) values 815{ 816 bool result; 817 @synchronized(self) 818 { 819 alGetListeneriv(parameter, values); 820 result = CHECK_AL_CALL(); 821 } 822 return result; 823} 824 825 826#pragma mark - 827#pragma mark Source Management 828 829+ (bool) genSources:(ALuint*) sourceIds numSources:(ALsizei) numSources 830{ 831 bool result; 832 @synchronized(self) 833 { 834 alGenSources(numSources, sourceIds); 835 result = CHECK_AL_CALL(); 836 } 837 return result; 838} 839 840+ (ALuint) genSource 841{ 842 ALuint sourceId; 843 @synchronized(self) 844 { 845 [self genSources:&sourceId numSources:1]; 846 sourceId = CHECK_AL_CALL() ? sourceId : (ALuint)AL_INVALID; 847 } 848 return sourceId; 849} 850 851+ (bool) deleteSources:(ALuint*) sourceIds numSources:(ALsizei) numSources 852{ 853 bool result; 854 @synchronized(self) 855 { 856 alDeleteSources(numSources, sourceIds); 857 result = CHECK_AL_CALL(); 858 } 859 return result; 860} 861 862+ (bool) deleteSource:(ALuint) sourceId 863{ 864 bool result; 865 @synchronized(self) 866 { 867 [self deleteSources:&sourceId numSources:1]; 868 result = CHECK_AL_CALL(); 869 } 870 return result; 871} 872 873+ (bool) isSource:(ALuint) sourceId 874{ 875 bool result; 876 @synchronized(self) 877 { 878 result = alIsSource(sourceId); 879 CHECK_AL_CALL(); 880 } 881 return result; 882} 883 884 885#pragma mark Source Properties 886 887+ (bool) sourcef:(ALuint) sourceId parameter:(ALenum) parameter value:(ALfloat) value 888{ 889 bool result; 890 @synchronized(self) 891 { 892 alSourcef(sourceId, parameter, value); 893 result = CHECK_AL_CALL(); 894 } 895 return result; 896} 897 898+ (bool) source3f:(ALuint) sourceId parameter:(ALenum) parameter v1:(ALfloat) v1 v2:(ALfloat) v2 v3:(ALfloat) v3 899{ 900 bool result; 901 @synchronized(self) 902 { 903 alSource3f(sourceId, parameter, v1, v2, v3); 904 result = CHECK_AL_CALL(); 905 } 906 return result; 907} 908 909+ (bool) sourcefv:(ALuint) sourceId parameter:(ALenum) parameter values:(ALfloat*) values 910{ 911 bool result; 912 @synchronized(self) 913 { 914 alSourcefv(sourceId, parameter, values); 915 result = CHECK_AL_CALL(); 916 } 917 return result; 918} 919 920+ (bool) sourcei:(ALuint) sourceId parameter:(ALenum) parameter value:(ALint) value 921{ 922 bool result; 923 @synchronized(self) 924 { 925 alSourcei(sourceId, parameter, value); 926 result = CHECK_AL_CALL(); 927 } 928 return result; 929} 930 931+ (bool) source3i:(ALuint) sourceId parameter:(ALenum) parameter v1:(ALint) v1 v2:(ALint) v2 v3:(ALint) v3 932{ 933 bool result; 934 @synchronized(self) 935 { 936 alSource3i(sourceId, parameter, v1, v2, v3); 937 result = CHECK_AL_CALL(); 938 } 939 return result; 940} 941 942+ (bool) sourceiv:(ALuint) sourceId parameter:(ALenum) parameter values:(ALint*) values 943{ 944 bool result; 945 @synchronized(self) 946 { 947 alSourceiv(sourceId, parameter, values); 948 result = CHECK_AL_CALL(); 949 } 950 return result; 951} 952 953 954+ (ALfloat) getSourcef:(ALuint) sourceId parameter:(ALenum) parameter 955{ 956 ALfloat value; 957 @synchronized(self) 958 { 959 alGetSourcef(sourceId, parameter, &value); 960 CHECK_AL_CALL(); 961 } 962 return value; 963} 964 965+ (bool) getSource3f:(ALuint) sourceId parameter:(ALenum) parameter v1:(ALfloat*) v1 v2:(ALfloat*) v2 v3:(ALfloat*) v3 966{ 967 bool result; 968 @synchronized(self) 969 { 970 alGetSource3f(sourceId, parameter, v1, v2, v3); 971 result = CHECK_AL_CALL(); 972 } 973 return result; 974} 975 976+ (bool) getSourcefv:(ALuint) sourceId parameter:(ALenum) parameter values:(ALfloat*) values 977{ 978 bool result; 979 @synchronized(self) 980 { 981 alGetSourcefv(sourceId, parameter, values); 982 result = CHECK_AL_CALL(); 983 } 984 return result; 985} 986 987+ (ALint) getSourcei:(ALuint) sourceId parameter:(ALenum) parameter 988{ 989 ALint value; 990 @synchronized(self) 991 { 992 alGetSourcei(sourceId, parameter, &value); 993 CHECK_AL_CALL(); 994 } 995 return value; 996} 997 998+ (bool) getSource3i:(ALuint) sourceId parameter:(ALenum) parameter v1:(ALint*) v1 v2:(ALint*) v2 v3:(ALint*) v3 999{ 1000 bool result; 1001 @synchronized(self) 1002 { 1003 alGetSource3i(sourceId, parameter, v1, v2, v3); 1004 result = CHECK_AL_CALL(); 1005 } 1006 return result; 1007} 1008 1009+ (bool) getSourceiv:(ALuint) sourceId parameter:(ALenum) parameter values:(ALint*) values 1010{ 1011 bool result; 1012 @synchronized(self) 1013 { 1014 alGetSourceiv(sourceId, parameter, values); 1015 result = CHECK_AL_CALL(); 1016 } 1017 return result; 1018} 1019 1020 1021#pragma mark Source Playback 1022 1023+ (bool) sourcePlay:(ALuint) sourceId 1024{ 1025 bool result; 1026 @synchronized(self) 1027 { 1028 alSourcePlay(sourceId); 1029 result = CHECK_AL_CALL(); 1030 } 1031 return result; 1032} 1033 1034+ (bool) sourcePlayv:(ALuint*) sourceIds numSources:(ALsizei) numSources 1035{ 1036 bool result; 1037 @synchronized(self) 1038 { 1039 alSourcePlayv(numSources, sourceIds); 1040 result = CHECK_AL_CALL(); 1041 } 1042 return result; 1043} 1044 1045+ (bool) sourcePause:(ALuint) sourceId 1046{ 1047 bool result; 1048 @synchronized(self) 1049 { 1050 alSourcePause(sourceId); 1051 result = CHECK_AL_CALL(); 1052 } 1053 return result; 1054} 1055 1056+ (bool) sourcePausev:(ALuint*) sourceIds numSources:(ALsizei) numSources 1057{ 1058 bool result; 1059 @synchronized(self) 1060 { 1061 alSourcePausev(numSources, sourceIds); 1062 result = CHECK_AL_CALL(); 1063 } 1064 return result; 1065} 1066 1067+ (bool) sourceStop:(ALuint) sourceId 1068{ 1069 bool result; 1070 @synchronized(self) 1071 { 1072 alSourceStop(sourceId); 1073 result = CHECK_AL_CALL(); 1074 } 1075 return result; 1076} 1077 1078+ (bool) sourceStopv:(ALuint*) sourceIds numSources:(ALsizei) numSources 1079{ 1080 bool result; 1081 @synchronized(self) 1082 { 1083 alSourceStopv(numSources, sourceIds); 1084 result = CHECK_AL_CALL(); 1085 } 1086 return result; 1087} 1088 1089+ (bool) sourceRewind:(ALuint) sourceId 1090{ 1091 bool result; 1092 @synchronized(self) 1093 { 1094 alSourceRewind(sourceId); 1095 result = CHECK_AL_CALL(); 1096 } 1097 return result; 1098} 1099 1100+ (bool) sourceRewindv:(ALuint*) sourceIds numSources:(ALsizei) numSources 1101{ 1102 bool result; 1103 @synchronized(self) 1104 { 1105 alSourceRewindv(numSources, sourceIds); 1106 result = CHECK_AL_CALL(); 1107 } 1108 return result; 1109} 1110 1111+ (bool) sourceQueueBuffers:(ALuint) sourceId numBuffers:(ALsizei) numBuffers bufferIds:(ALuint*) bufferIds 1112{ 1113 bool result; 1114 @synchronized(self) 1115 { 1116 alSourceQueueBuffers(sourceId, numBuffers, bufferIds); 1117 result = CHECK_AL_CALL(); 1118 } 1119 return result; 1120} 1121 1122+ (bool) sourceUnqueueBuffers:(ALuint) sourceId numBuffers:(ALsizei) numBuffers bufferIds:(ALuint*) bufferIds 1123{ 1124 bool result; 1125 @synchronized(self) 1126 { 1127 alSourceUnqueueBuffers(sourceId, numBuffers, bufferIds); 1128 result = CHECK_AL_CALL(); 1129 } 1130 return result; 1131} 1132 1133 1134#pragma mark - 1135#pragma mark Buffer Management 1136 1137+ (bool) genBuffers:(ALuint*) bufferIds numBuffers:(ALsizei) numBuffers 1138{ 1139 bool result; 1140 @synchronized(self) 1141 { 1142 alGenBuffers(numBuffers, bufferIds); 1143 result = CHECK_AL_CALL(); 1144 } 1145 return result; 1146} 1147 1148+ (ALuint) genBuffer 1149{ 1150 ALuint bufferId; 1151 @synchronized(self) 1152 { 1153 [self genBuffers:&bufferId numBuffers:1]; 1154 bufferId = CHECK_AL_CALL() ? bufferId : (ALuint)AL_INVALID; 1155 } 1156 return bufferId; 1157} 1158 1159+ (bool) deleteBuffers:(ALuint*) bufferIds numBuffers:(ALsizei) numBuffers 1160{ 1161 bool result; 1162 @synchronized(self) 1163 { 1164 alDeleteBuffers(numBuffers, bufferIds); 1165 result = CHECK_AL_CALL(); 1166 } 1167 return result; 1168} 1169 1170+ (bool) deleteBuffer:(ALuint) bufferId 1171{ 1172 bool result; 1173 @synchronized(self) 1174 { 1175 [self deleteBuffers:&bufferId numBuffers:1]; 1176 result = CHECK_AL_CALL(); 1177 } 1178 return result; 1179} 1180 1181+ (bool) isBuffer:(ALuint) bufferId 1182{ 1183 bool result; 1184 @synchronized(self) 1185 { 1186 result = alIsBuffer(bufferId); 1187 CHECK_AL_CALL(); 1188 } 1189 return result; 1190} 1191 1192+ (bool) bufferData:(ALuint) bufferId format:(ALenum) format data:(const ALvoid*) data size:(ALsizei) size frequency:(ALsizei) frequency 1193{ 1194 bool result; 1195 @synchronized(self) 1196 { 1197 alBufferData(bufferId, format, data, size, frequency); 1198 result = CHECK_AL_CALL(); 1199 } 1200 return result; 1201} 1202 1203 1204#pragma mark Buffer Properties 1205 1206+ (bool) bufferf:(ALuint) bufferId parameter:(ALenum) parameter value:(ALfloat) value 1207{ 1208 bool result; 1209 @synchronized(self) 1210 { 1211 alBufferf(bufferId, parameter, value); 1212 result = CHECK_AL_CALL(); 1213 } 1214 return result; 1215} 1216 1217+ (bool) buffer3f:(ALuint) bufferId parameter:(ALenum) parameter v1:(ALfloat) v1 v2:(ALfloat) v2 v3:(ALfloat) v3 1218{ 1219 bool result; 1220 @synchronized(self) 1221 { 1222 alBuffer3f(bufferId, parameter, v1, v2, v3); 1223 result = CHECK_AL_CALL(); 1224 } 1225 return result; 1226} 1227 1228+ (bool) bufferfv:(ALuint) bufferId parameter:(ALenum) parameter values:(ALfloat*) values 1229{ 1230 bool result; 1231 @synchronized(self) 1232 { 1233 alBufferfv(bufferId, parameter, values); 1234 result = CHECK_AL_CALL(); 1235 } 1236 return result; 1237} 1238 1239+ (bool) bufferi:(ALuint) bufferId parameter:(ALenum) parameter value:(ALint) value 1240{ 1241 bool result; 1242 @synchronized(self) 1243 { 1244 alBufferi(bufferId, parameter, value); 1245 result = CHECK_AL_CALL(); 1246 } 1247 return result; 1248} 1249 1250+ (bool) buffer3i:(ALuint) bufferId parameter:(ALenum) parameter v1:(ALint) v1 v2:(ALint) v2 v3:(ALint) v3 1251{ 1252 bool result; 1253 @synchronized(self) 1254 { 1255 alBuffer3i(bufferId, parameter, v1, v2, v3); 1256 result = CHECK_AL_CALL(); 1257 } 1258 return result; 1259} 1260 1261+ (bool) bufferiv:(ALuint) bufferId parameter:(ALenum) parameter values:(ALint*) values 1262{ 1263 bool result; 1264 @synchronized(self) 1265 { 1266 alBufferiv(bufferId, parameter, values); 1267 result = CHECK_AL_CALL(); 1268 } 1269 return result; 1270} 1271 1272 1273+ (ALfloat) getBufferf:(ALuint) bufferId parameter:(ALenum) parameter 1274{ 1275 ALfloat value; 1276 @synchronized(self) 1277 { 1278 alGetBufferf(bufferId, parameter, &value); 1279 CHECK_AL_CALL(); 1280 } 1281 return value; 1282} 1283 1284+ (bool) getBuffer3f:(ALuint) bufferId parameter:(ALenum) parameter v1:(ALfloat*) v1 v2:(ALfloat*) v2 v3:(ALfloat*) v3 1285{ 1286 bool result; 1287 @synchronized(self) 1288 { 1289 alGetBuffer3f(bufferId, parameter, v1, v2, v3); 1290 result = CHECK_AL_CALL(); 1291 } 1292 return result; 1293} 1294 1295+ (bool) getBufferfv:(ALuint) bufferId parameter:(ALenum) parameter values:(ALfloat*) values 1296{ 1297 bool result; 1298 @synchronized(self) 1299 { 1300 alGetBufferfv(bufferId, parameter, values); 1301 result = CHECK_AL_CALL(); 1302 } 1303 return result; 1304} 1305 1306+ (ALint) getBufferi:(ALuint) bufferId parameter:(ALenum) parameter 1307{ 1308 ALint value; 1309 @synchronized(self) 1310 { 1311 alGetBufferi(bufferId, parameter, &value); 1312 CHECK_AL_CALL(); 1313 } 1314 return value; 1315} 1316 1317+ (bool) getBuffer3i:(ALuint) bufferId parameter:(ALenum) parameter v1:(ALint*) v1 v2:(ALint*) v2 v3:(ALint*) v3 1318{ 1319 bool result; 1320 @synchronized(self) 1321 { 1322 alGetBuffer3i(bufferId, parameter, v1, v2, v3); 1323 result = CHECK_AL_CALL(); 1324 } 1325 return result; 1326} 1327 1328+ (bool) getBufferiv:(ALuint) bufferId parameter:(ALenum) parameter values:(ALint*) values 1329{ 1330 bool result; 1331 @synchronized(self) 1332 { 1333 alGetBufferiv(bufferId, parameter, values); 1334 result = CHECK_AL_CALL(); 1335 } 1336 return result; 1337} 1338 1339 1340#pragma mark - 1341#pragma mark Apple Extensions 1342 1343+ (ALdouble) getMixerOutputDataRate 1344{ 1345 if(NULL == alcGetMacOSXMixerOutputRate) 1346 { 1347 alcGetMacOSXMixerOutputRate = (alcMacOSXGetMixerOutputRateProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alcMacOSXGetMixerOutputRate"); 1348 if(NULL == alcGetMacOSXMixerOutputRate) 1349 { 1350 OAL_LOG_ERROR(@"Could not get proc pointer for \"alcMacOSXMixerOutputRate\"."); 1351 } 1352 } 1353 1354 ALdouble result; 1355 @synchronized(self) 1356 { 1357 result = alcGetMacOSXMixerOutputRate(); 1358 CHECK_AL_CALL(); 1359 } 1360 return result; 1361} 1362 1363+ (void) setMixerOutputDataRate:(ALdouble) frequency 1364{ 1365 if(NULL == alcMacOSXMixerOutputRate) 1366 { 1367 alcMacOSXMixerOutputRate = (alcMacOSXMixerOutputRateProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alcMacOSXMixerOutputRate"); 1368 if(NULL == alcMacOSXMixerOutputRate) 1369 { 1370 OAL_LOG_ERROR(@"Could not get proc pointer for \"alcMacOSXMixerOutputRate\"."); 1371 } 1372 } 1373 1374 alcMacOSXMixerOutputRate(frequency); 1375} 1376 1377+ (bool) bufferDataStatic:(ALuint) bufferId format:(ALenum) format data:(const ALvoid*) data size:(ALsizei) size frequency:(ALsizei) frequency 1378{ 1379 if(NULL == alBufferDataStatic) 1380 { 1381 alBufferDataStatic = (alBufferDataStaticProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alBufferDataStatic"); 1382 if(NULL == alBufferDataStatic) 1383 { 1384 OAL_LOG_ERROR(@"Could not get proc pointer for \"alBufferDataStatic\"."); 1385 } 1386 } 1387 1388 bool result; 1389 @synchronized(self) 1390 { 1391 alBufferDataStatic(bufferId, format, data, size, frequency); 1392 result = CHECK_AL_CALL(); 1393 } 1394 return result; 1395} 1396 1397@end