# HG changeset patch # User koda # Date 1271493034 0 # Node ID a767dd3786b54652274e0004a02afcb54c9811fe # Parent ac5d14a3548210728247bedcf9c35ca9fc475edd OpenAL makes a comeback! (might require some cleanup) removed sdl_mixer from ifrontend as it's too buggy updated hedgwars.pro project file diff -r ac5d14a35482 -r a767dd3786b5 CMakeLists.txt --- a/CMakeLists.txt Sat Apr 17 04:59:10 2010 +0000 +++ b/CMakeLists.txt Sat Apr 17 08:30:34 2010 +0000 @@ -228,7 +228,7 @@ "hwconsts.cpp$" "playlist.inc$" "CPack" - "^${PROJECT_SOURCE_DIR}/openalbridge" + "^${PROJECT_SOURCE_DIR}/misc/openalbridge" "^${PROJECT_SOURCE_DIR}/cocoaTouch" "^${PROJECT_SOURCE_DIR}/bin/[a-z]" "^${PROJECT_SOURCE_DIR}/tools/templates" diff -r ac5d14a35482 -r a767dd3786b5 cocoaTouch/VoicesViewController.h --- a/cocoaTouch/VoicesViewController.h Sat Apr 17 04:59:10 2010 +0000 +++ b/cocoaTouch/VoicesViewController.h Sat Apr 17 08:30:34 2010 +0000 @@ -7,7 +7,6 @@ // #import -#import "SDL_mixer.h" @interface VoicesViewController : UITableViewController { @@ -16,7 +15,7 @@ NSArray *voiceArray; NSIndexPath *lastIndexPath; - Mix_Chunk *voiceBeingPlayed; + int voiceBeingPlayed; } @property (nonatomic,retain) NSMutableDictionary *teamDictionary; diff -r ac5d14a35482 -r a767dd3786b5 cocoaTouch/VoicesViewController.m --- a/cocoaTouch/VoicesViewController.m Sat Apr 17 04:59:10 2010 +0000 +++ b/cocoaTouch/VoicesViewController.m Sat Apr 17 08:30:34 2010 +0000 @@ -8,6 +8,7 @@ #import "VoicesViewController.h" #import "CommodityFunctions.h" +#import "openalbridge.h" @implementation VoicesViewController @@ -25,8 +26,8 @@ [super viewDidLoad]; srandom(time(NULL)); - Mix_OpenAudio(44100, AUDIO_S16SYS, 2, 1024); - voiceBeingPlayed = NULL; + openal_init("Hedgewars", 0, 3); + voiceBeingPlayed = -1; // load all the voices names and store them into voiceArray NSArray *array = [[NSFileManager defaultManager] contentsOfDirectoryAtPath:VOICES_DIRECTORY() error:NULL]; @@ -48,10 +49,9 @@ - (void)viewWillDisappear:(BOOL)animated { [super viewWillDisappear:animated]; - if(voiceBeingPlayed != NULL) { - Mix_HaltChannel(-1); - Mix_FreeChunk(voiceBeingPlayed); - voiceBeingPlayed = NULL; + if(voiceBeingPlayed >= 0) { + openal_freesound(voiceBeingPlayed); + voiceBeingPlayed = -1; } } @@ -134,9 +134,6 @@ return YES; } */ --(void) allowSelection { - self.tableView.allowsSelection = YES; -} #pragma mark - #pragma mark Table view delegate @@ -144,10 +141,6 @@ int newRow = [indexPath row]; int oldRow = (lastIndexPath != nil) ? [lastIndexPath row] : -1; - // avoid a crash in sdl_mixer - self.tableView.allowsSelection = NO; - [NSTimer scheduledTimerWithTimeInterval:1 target:self selector:@selector(allowSelection) userInfo:nil repeats:NO]; - if (newRow != oldRow) { [teamDictionary setObject:[voiceArray objectAtIndex:newRow] forKey:@"voicepack"]; @@ -160,10 +153,10 @@ } [self.tableView deselectRowAtIndexPath:indexPath animated:YES]; - if (voiceBeingPlayed != NULL) { - Mix_HaltChannel(-1); - Mix_FreeChunk(voiceBeingPlayed); - voiceBeingPlayed = NULL; + if (voiceBeingPlayed >= 0) { + openal_stopsound(voiceBeingPlayed); + openal_freesound(voiceBeingPlayed); + voiceBeingPlayed = -1; } // the keyword static prevents re-initialization of the variable @@ -172,18 +165,18 @@ int index = random() % [array count]; - voiceBeingPlayed = Mix_LoadWAV([[voiceDir stringByAppendingString:[array objectAtIndex:index]] UTF8String]); + voiceBeingPlayed = openal_loadfile([[voiceDir stringByAppendingString:[array objectAtIndex:index]] UTF8String]); [voiceDir release]; - Mix_PlayChannel(-1, voiceBeingPlayed, 0); + openal_playsound(voiceBeingPlayed); } #pragma mark - #pragma mark Memory management - (void)didReceiveMemoryWarning { - Mix_HaltChannel(-1); - Mix_FreeChunk(voiceBeingPlayed); - voiceBeingPlayed = NULL; + openal_stopsound(voiceBeingPlayed); + openal_freesound(voiceBeingPlayed); + voiceBeingPlayed = -1; // Releases the view if it doesn't have a superview. [super didReceiveMemoryWarning]; // Relinquish ownership any cached data, images, etc that aren't in use. @@ -192,8 +185,8 @@ - (void)viewDidUnload { [super viewDidUnload]; - Mix_CloseAudio(); - voiceBeingPlayed = NULL; + openal_close(); + voiceBeingPlayed = -1; self.lastIndexPath = nil; self.teamDictionary = nil; self.voiceArray = nil; diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/CMakeLists.txt --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/CMakeLists.txt Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,41 @@ +find_package(OpenAL REQUIRED) +find_package(OggVorbis REQUIRED) +include_directories(${OPENAL_INCLUDE_DIR}) +include_directories(${OGGVORBIS_INCLUDE_DIRS}) + +#set destination directory for library +set(LIBRARY_OUTPUT_PATH ${EXECUTABLE_OUTPUT_PATH}) + +#list of source files for libraries +set(openal_src + openalbridge.c loaders.c wrappers.c errlib.c +) + +#build a static library for human systems +set (build_type STATIC) + +#visualstudio and windows in general doesn't like static linking, so we're building the library in shared mode +if(WIN32) +#workaround for visualstudio (wants headers in the source list) + set(openal_src + openalbridge.h loaders.h wrappers.h globals.h oggvorbis.h errlib.h ${openal_src} + ) +#deps for the shared library + link_libraries(${VORBISFILE_LIBRARY}) + link_libraries(${VORBIS_LIBRARY}) + link_libraries(${OGG_LIBRARY}) + link_libraries(${OPENAL_LIBRARY}) +#build a shared library + set (build_type SHARED) +endif() + +#compiles and links actual library +add_library (openalbridge ${build_type} ${openal_src}) + +if(WIN32) +if(MSVC) + SET_TARGET_PROPERTIES(openalbridge PROPERTIES LINK_FLAGS /DEF:openalbridge.def) +endif(MSVC) +#install it in the executable directory + install(TARGETS openalbridge DESTINATION bin) +endif(WIN32) diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/errlib.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/errlib.c Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,96 @@ +/* + + module: errlib.c + + purpose: library of error functions + + reference: Stevens, Unix network programming (2ed), p.922 + + */ + +#include "errlib.h" + + +#define MAXLINE 4095 + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + int daemon_proc = 0; /* set to 0 if stdout/stderr available, else set to 1 */ + + static void err_doit (int errnoflag, int level, const char *fmt, va_list ap) + { + int errno_save = errno, n; + char buf[MAXLINE+1]; + + vsnprintf (buf, MAXLINE, fmt, ap); + n = strlen(buf); + if (errnoflag) + snprintf (buf+n, MAXLINE-n, ": %s", strerror(errno_save)); + strcat (buf, "\n"); + + if (daemon_proc) + syslog (level, buf); + else { + fflush (stdout); + fprintf (stderr, "%s", buf); + fflush (stderr); + } + + return; + } + + void err_ret (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_INFO, fmt, ap); + va_end (ap); + return; + } + + void err_sys (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_ERR, fmt, ap); + va_end (ap); + exit (1); + } + + void err_msg (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (0, LOG_INFO, fmt, ap); + va_end (ap); + return; + } + + void err_quit (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (0, LOG_ERR, fmt, ap); + va_end (ap); + exit (1); + } + + void err_dump (const char *fmt, ...) + { + va_list ap; + + va_start (ap, fmt); + err_doit (1, LOG_ERR, fmt, ap); + va_end (ap); + abort(); + } + +#ifdef __CPLUSPLUS +} +#endif diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/errlib.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/errlib.h Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,43 @@ +/* + + module: errlib.h + + purpose: definitions of function sin errlib.c + + reference: Stevens, Unix network programming (2ed), p.922 + + */ + +#ifndef _ERRLIB_H +#define _ERRLIB_H + +#include "globals.h" + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + extern int daemon_proc; + + void err_msg (const char *fmt, ...); + void err_quit (const char *fmt, ...); + void err_ret (const char *fmt, ...); + void err_sys (const char *fmt, ...); + void err_dump (const char *fmt, ...); + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_ERRLIB_H*/ + +/* + suggested error string ( PROG ) LEVEL - TEXT : ERRNO + + errno? closeprog? log level + err_msg no no LOG_INFO + err_quit no exit(1) LOG_ERR + err_ret si no LOG_INFO + err_sys si exit(1) LOG_ERR + err_dump si abort( ) LOG_ERR + */ \ No newline at end of file diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/globals.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/globals.h Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,154 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#ifndef _OALB_GLOBALS_H +#define _OALB_GLOBALS_H + +#include +#include +#include +#include +#include +#include + +#ifndef _WIN32 +#include +#include +#else +#include +#define syslog(x,y) fprintf(stderr,y) +#define LOG_INFO 6 +#define LOG_ERR 3 +#endif + +#include "al.h" +#include "errlib.h" + + +/*control debug verbosity*/ +#ifdef TRACE +#ifndef DEBUG +#define DEBUG +#endif +#endif + +/** 1.0 02/03/10 - Defines cross-platform sleep, usleep, etc. [Wu Yongwei] **/ +#ifndef _SLEEP_H +#define _SLEEP_H +#ifdef _WIN32 +# if defined(_NEED_SLEEP_ONLY) && (defined(_MSC_VER) || defined(__MINGW32__)) +# include +# define sleep(t) _sleep((t) * 1000) +# else +# define WIN32_LEAN_AND_MEAN +# include +# define sleep(t) Sleep((t) * 1000) +# endif +# ifndef _NEED_SLEEP_ONLY +# define msleep(t) Sleep(t) +# define usleep(t) Sleep((t) / 1000) +# endif +#else +# include +# ifndef _NEED_SLEEP_ONLY +# define msleep(t) usleep((t) * 1000) +# endif +#endif +#endif /* _SLEEP_H */ + + +/* check compiler requirements */ /*FIXME*/ +#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) +#warning __BIG_ENDIAN__ or __LITTLE_ENDIAN__ not found, going to set __LITTLE_ENDIAN__ as default +#define __LITTLE_ENDIAN__ 1 +//#error Do not know the endianess of this architecture +#endif + +/* use byteswap macros from the host system, hopefully optimized ones ;-) + * or define our own version, simple, stupid, straight-forward... */ +#ifdef HAVE_BYTESWAP_H +#include +#else +#define bswap_16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8)) +#define bswap_32(x) ((((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | \ +(((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) ) +#endif /* HAVE_BYTESWAP_H */ + +/* swap numbers accordingly to architecture automatically */ +#ifdef __LITTLE_ENDIAN__ +#define ENDIAN_LITTLE_32(x) x +#define ENDIAN_BIG_32(x) bswap_32(x) +#define ENDIAN_LITTLE_16(x) x +#define ENDIAN_BIG_16(x) bswap_16(x) +#elif __BIG_ENDIAN__ +#define ENDIAN_LITTLE_32(x) bswap_32(x) +#define ENDIAN_BIG_32(x) x +#define ENDIAN_LITTLE_16(x) bswap_16(x) +#define ENDIAN_BIG_16(x) x +#endif + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + /*data type for WAV header*/ +#pragma pack(1) + typedef struct _WAV_header_t { + uint32_t ChunkID; + uint32_t ChunkSize; + uint32_t Format; + uint32_t Subchunk1ID; + uint32_t Subchunk1Size; + uint16_t AudioFormat; + uint16_t NumChannels; + uint32_t SampleRate; + uint32_t ByteRate; + uint16_t BlockAlign; + uint16_t BitsPerSample; + uint32_t Subchunk2ID; + uint32_t Subchunk2Size; + } WAV_header_t; +#pragma pack() + + /*data type for passing data between threads*/ +#pragma pack(1) + typedef struct _fade_t { + uint32_t index; + uint16_t quantity; + } fade_t; +#pragma pack() + + + /*file format defines*/ +#define OGG_FILE_FORMAT 0x4F676753 +#define WAV_FILE_FORMAT 0x52494646 +#define WAV_HEADER_SUBCHUNK2ID 0x64617461 + + + /*other defines*/ +#define FADE_IN 0 +#define FADE_OUT 1 + + char *prog; + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_OALB_GLOBALS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/loaders.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/loaders.c Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,248 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#include "loaders.h" +#include "wrappers.h" +#include "vorbis/vorbisfile.h" + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) { + WAV_header_t WAVHeader; + FILE *wavfile; + int32_t t; + uint32_t n = 0; + uint8_t sub0, sub1, sub2, sub3; + + wavfile = Fopen(filename, "rb"); + + fread(&WAVHeader.ChunkID, sizeof(uint32_t), 1, wavfile); /*RIFF*/ + fread(&WAVHeader.ChunkSize, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.Format, sizeof(uint32_t), 1, wavfile); /*WAVE*/ + +#ifdef DEBUG + fprintf(stderr, "ChunkID: %X\n", ENDIAN_BIG_32(WAVHeader.ChunkID)); + fprintf(stderr, "ChunkSize: %d\n", ENDIAN_LITTLE_32(WAVHeader.ChunkSize)); + fprintf(stderr, "Format: %X\n", ENDIAN_BIG_32(WAVHeader.Format)); +#endif + + fread(&WAVHeader.Subchunk1ID, sizeof(uint32_t), 1, wavfile); /*fmt */ + fread(&WAVHeader.Subchunk1Size, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.AudioFormat, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.NumChannels, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.SampleRate, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.ByteRate, sizeof(uint32_t), 1, wavfile); + fread(&WAVHeader.BlockAlign, sizeof(uint16_t), 1, wavfile); + fread(&WAVHeader.BitsPerSample, sizeof(uint16_t), 1, wavfile); + +#ifdef DEBUG + fprintf(stderr, "Subchunk1ID: %X\n", ENDIAN_BIG_32(WAVHeader.Subchunk1ID)); + fprintf(stderr, "Subchunk1Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk1Size)); + fprintf(stderr, "AudioFormat: %d\n", ENDIAN_LITTLE_16(WAVHeader.AudioFormat)); + fprintf(stderr, "NumChannels: %d\n", ENDIAN_LITTLE_16(WAVHeader.NumChannels)); + fprintf(stderr, "SampleRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.SampleRate)); + fprintf(stderr, "ByteRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.ByteRate)); + fprintf(stderr, "BlockAlign: %d\n", ENDIAN_LITTLE_16(WAVHeader.BlockAlign)); + fprintf(stderr, "BitsPerSample: %d\n", ENDIAN_LITTLE_16(WAVHeader.BitsPerSample)); +#endif + + /*remove useless header chunks by looking for the WAV_HEADER_SUBCHUNK2ID integer */ + do { + t = fread(&sub0, sizeof(uint8_t), 1, wavfile); + if(sub0 == 0x64) { + t = fread(&sub1, sizeof(uint8_t), 1, wavfile); + if(sub1 == 0x61) { + t = fread(&sub2, sizeof(uint8_t), 1, wavfile); + if(sub2 == 0x74) { + t = fread(&sub3, sizeof(uint8_t), 1, wavfile); + if(sub3 == 0x61) { + WAVHeader.Subchunk2ID = WAV_HEADER_SUBCHUNK2ID; + break; + } + } + } + } + + if (t <= 0) { + /*eof*/ + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header", prog); + return AL_FALSE; + } + } while (1); + + fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile); + +#ifdef DEBUG + fprintf(stderr, "Subchunk2ID: %X\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2ID)); + fprintf(stderr, "Subchunk2Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); +#endif + + *data = (char*) Malloc (sizeof(char) * ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); + + /*read the actual sound data*/ + do { + n += fread(&((*data)[n]), sizeof(uint8_t), 4, wavfile); + } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); + + fclose(wavfile); + +#ifdef DEBUG + err_msg("(%s) INFO - WAV data loaded", prog); +#endif + + /*set parameters for OpenAL*/ + /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/ + if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) + *format = AL_FORMAT_MONO8; + else { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) + *format = AL_FORMAT_MONO16; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); + return AL_FALSE; + } + } + } else { + if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) + *format = AL_FORMAT_STEREO8; + else { + if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) + *format = AL_FORMAT_STEREO16; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); + return AL_FALSE; + } + } + } else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong WAV header [format value]", prog); + return AL_FALSE; + } + } + + *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size); + *freq = ENDIAN_LITTLE_32(WAVHeader.SampleRate); + return AL_TRUE; + } + + + int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) { + /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */ + + /*stream handle*/ + OggVorbis_File oggStream; + /*some formatting data*/ + vorbis_info *vorbisInfo; + /*length of the decoded data*/ + int64_t pcm_length; + /*other vars*/ + int section, result, size, endianness; +#ifdef DEBUG + int i; + /*other less useful data*/ + vorbis_comment *vorbisComment; +#endif + + result = ov_fopen((char*) filename, &oggStream); + if (result < 0) { + errno = EINVAL; + err_ret("(%s) ERROR - ov_fopen() failed with %X", prog, result); + ov_clear(&oggStream); + return AL_FALSE; + } + + /*load OGG header and determine the decoded data size*/ + vorbisInfo = ov_info(&oggStream, -1); + pcm_length = ov_pcm_total(&oggStream, -1) << vorbisInfo->channels; + +#ifdef DEBUG + vorbisComment = ov_comment(&oggStream, -1); + fprintf(stderr, "Version: %d\n", vorbisInfo->version); + fprintf(stderr, "Channels: %d\n", vorbisInfo->channels); + fprintf(stderr, "Rate (Hz): %ld\n", vorbisInfo->rate); + fprintf(stderr, "Bitrate Upper: %ld\n", vorbisInfo->bitrate_upper); + fprintf(stderr, "Bitrate Nominal: %ld\n", vorbisInfo->bitrate_nominal); + fprintf(stderr, "Bitrate Lower: %ld\n", vorbisInfo->bitrate_lower); + fprintf(stderr, "Bitrate Windows: %ld\n", vorbisInfo->bitrate_window); + fprintf(stderr, "Vendor: %s\n", vorbisComment->vendor); + fprintf(stderr, "PCM data size: %lld\n", pcm_length); + fprintf(stderr, "# comment: %d\n", vorbisComment->comments); + for (i = 0; i < vorbisComment->comments; i++) + fprintf(stderr, "\tComment %d: %s\n", i, vorbisComment->user_comments[i]); +#endif + + /*allocates enough room for the decoded data*/ + *data = (char*) Malloc (sizeof(char) * pcm_length); + + /*there *should* not be ogg at 8 bits*/ + if (vorbisInfo->channels == 1) + *format = AL_FORMAT_MONO16; + else { + if (vorbisInfo->channels == 2) + *format = AL_FORMAT_STEREO16; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - wrong OGG header [channel %d]", prog, vorbisInfo->channels); + ov_clear(&oggStream); + return AL_FALSE; + } + } + + size = 0; +#ifdef __LITTLE_ENDIAN__ + endianness = 0; +#elif __BIG_ENDIAN__ + endianness = 1; +#endif + while (size < pcm_length) { + /*ov_read decodes the ogg stream and storse the pcm in data*/ + result = ov_read (&oggStream, *data + size, pcm_length - size, endianness, 2, 1, §ion); + if (result > 0) { + size += result; + } else { + if (result == 0) + break; + else { + errno = EILSEQ; + err_ret("(%s) ERROR - End of file from OGG stream", prog); + ov_clear(&oggStream); + return AL_FALSE; + } + } + } + + /*set the last fields*/ + *bitsize = size; + *freq = vorbisInfo->rate; + + /*cleaning time*/ + ov_clear(&oggStream); + + return AL_TRUE; + } + +#ifdef __CPLUSPLUS +} +#endif diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/loaders.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/loaders.h Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,36 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#ifndef _OALB_LOADERS_H +#define _OALB_LOADERS_H + +#include "globals.h" + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + int load_wavpcm (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); + int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_OALB_LOADERS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/openalbridge.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/openalbridge.c Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,523 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#include "openalbridge.h" +#include "globals.h" +#include "wrappers.h" +#include "alc.h" +#include "loaders.h" + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + /*Sources are points emitting sound*/ + ALuint *Sources; + /*Buffers hold sound data*/ + ALuint *Buffers; + /*index for Sources and Buffers*/ + ALuint globalindex, globalsize, increment; + + ALboolean openalReady = AL_FALSE; + + ALboolean openal_close (void) { + /*Stop all sounds, deallocate all memory and close OpenAL */ + ALCcontext *context; + ALCdevice *device; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alSourceStopv (globalsize, Sources); + alDeleteSources (globalsize, Sources); + alDeleteBuffers (globalsize, Buffers); + + free(Sources); + free(Buffers); + + context = alcGetCurrentContext(); + device = alcGetContextsDevice(context); + + alcMakeContextCurrent(NULL); + alcDestroyContext(context); + alcCloseDevice(device); + + openalReady = AL_FALSE; + + err_msg("(%s) INFO - OpenAL closed", prog); + + return AL_TRUE; + } + + ALboolean openal_ready(void) { + return openalReady; + } + + ALboolean openal_init(char* programname, ALboolean usehardware, uint32_t memorysize) { + /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ + ALCcontext *context; + ALCdevice *device; + const ALCchar *default_device; + + prog = programname; + + /*Position of the listener*/ + ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 }; + /*Velocity of the listener*/ + ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 }; + /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ + ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 }; + + if (openalReady == AL_TRUE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL already initialized", prog); + return AL_FALSE; + } + + if (usehardware == AL_TRUE) { + default_device = alcGetString(NULL, ALC_DEFAULT_DEVICE_SPECIFIER); + device = alcOpenDevice(default_device); + } else + device = alcOpenDevice("Generic Software"); + + if (device == NULL) { + errno = ENODEV; + err_ret("(%s) WARN - Failed to open sound device", prog); + return AL_FALSE; + } + err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); + + context = alcCreateContext(device, NULL); + alcMakeContextCurrent(context); + alcProcessContext(context); + + if (AlGetError("(%s) WARN - Failed to create a new contex") != AL_TRUE) + return AL_FALSE; + + /*allocate memory space for buffers and sources*/ + if (memorysize == 0) + globalsize = 50; + else + globalsize = memorysize; + increment = globalsize; + + Buffers = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + Sources = (ALuint*) Malloc(sizeof(ALuint)*globalsize); + + /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ + alListenerf (AL_GAIN, 1.0f ); + alListenerfv(AL_POSITION, ListenerPos); + alListenerfv(AL_VELOCITY, ListenerVel); + alListenerfv(AL_ORIENTATION, ListenerOri); + + if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) + return AL_FALSE; + + openalReady = AL_TRUE; + + alGetError(); /* clear any AL errors beforehand */ + return AL_TRUE; + } + + + ALboolean helper_realloc (void) { + /*expands allocated memory when loading more sound files than expected*/ + int oldsize = globalsize; + globalsize += increment; + + err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); + + Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); + Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); + + return AL_TRUE; + } + + + ALint openal_loadfile (const char *filename){ + /*Open a file, load into memory and allocate the Source buffer for playing*/ + ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ + ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ + ALenum format; + ALsizei bitsize, freq; + char *data; + uint32_t fileformat; + ALenum error; + FILE *fp; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*when the buffers are all used, we can expand memory to accept new files*/ + if (globalindex == globalsize) + helper_realloc(); + + /*detect the file format, as written in the first 4 bytes of the header*/ + fp = Fopen (filename, "rb"); + + if (fp == NULL) + return -1; + + error = fread (&fileformat, sizeof(uint32_t), 1, fp); + fclose (fp); + + if (error < 0) { + errno = EIO; + err_ret("(%s) ERROR - File %s is too short", prog, filename); + return -2; + } + + /*prepare the buffer to receive data*/ + alGenBuffers(1, &Buffers[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) + return -3; + + /*prepare the source to emit sound*/ + alGenSources(1, &Sources[globalindex]); + + if (AlGetError("(%s) ERROR - Failed to allocate memory for sources") != AL_TRUE) + return -4; + + + switch (ENDIAN_BIG_32(fileformat)) { + case OGG_FILE_FORMAT: + error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); + break; + case WAV_FILE_FORMAT: + error = load_wavpcm (filename, &format, &data, &bitsize, &freq); + break; + default: + errno = EINVAL; + err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(fileformat)); + return -5; + break; + } + + + /*copy pcm data in one buffer*/ + alBufferData(Buffers[globalindex], format, data, bitsize, freq); + free(data); /*deallocate data to save memory*/ + + if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) + return -6; + + /*set source properties that it will use when it's in playback*/ + alSourcei (Sources[globalindex], AL_BUFFER, Buffers[globalindex] ); + alSourcef (Sources[globalindex], AL_PITCH, 1.0f ); + alSourcef (Sources[globalindex], AL_GAIN, 1.0f ); + alSourcefv(Sources[globalindex], AL_POSITION, SourcePos ); + alSourcefv(Sources[globalindex], AL_VELOCITY, SourceVel ); + alSourcei (Sources[globalindex], AL_LOOPING, 0 ); + + if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) + return -7; + + alGetError(); /* clear any AL errors beforehand */ + + /*returns the index of the source you just loaded, increments it and exits*/ + return globalindex++; + } + + + ALboolean openal_toggleloop (uint32_t index){ + /*Set or unset looping mode*/ + ALint loop; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + alGetSourcei (Sources[index], AL_LOOPING, &loop); + alSourcei (Sources[index], AL_LOOPING, !((uint8_t) loop) & 0x00000001); + if (AlGetError("(%s) ERROR - Failed to get or set loop property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_setvolume (uint32_t index, uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + if (percentage > 100) + percentage = 100; + alSourcef (Sources[index], AL_GAIN, (float) percentage/100.0f); + if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_setglobalvolume (uint8_t percentage) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Set volume for all sounds*/ + if (percentage > 100) + percentage = 100; + alListenerf (AL_GAIN, (float) percentage/100.0f); + if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_togglemute () { + /*Mute or unmute sound*/ + ALfloat mute; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + alGetListenerf (AL_GAIN, &mute); + if (mute > 0) + mute = 0; + else + mute = 1.0; + alListenerf (AL_GAIN, mute); + if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_fade (uint32_t index, uint16_t quantity, ALboolean direction) { + /*Fade in or out by calling a helper thread*/ +#ifndef _WIN32 + pthread_t thread; +#else + HANDLE Thread; + DWORD threadID; +#endif + fade_t *fade; + + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + fade = (fade_t*) Malloc(sizeof(fade_t)); + fade->index = index; + fade->quantity = quantity; + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + switch (direction) { + case FADE_IN: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadein, (void*) fade); +#else + Thread = _beginthread(&helper_fadein, 0, (void*) fade); +#endif + break; + case FADE_OUT: +#ifndef _WIN32 + pthread_create(&thread, NULL, helper_fadeout, (void*) fade); +#else + Thread = _beginthread(&helper_fadeout, 0, (void*) fade); +#endif + break; + default: + errno = EINVAL; + err_ret("(%s) ERROR - Unknown direction for fading", prog, index, globalindex); + free(fade); + return AL_FALSE; + break; + } + +#ifndef _WIN32 + pthread_detach(thread); +#endif + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_fadeout (uint32_t index, uint16_t quantity) { + /*wrapper for fadeout*/ + return openal_fade(index, quantity, FADE_OUT); + } + + + ALboolean openal_fadein (uint32_t index, uint16_t quantity) { + /*wrapper for fadein*/ + return openal_fade(index, quantity, FADE_IN); + } + + + ALboolean openal_setposition (uint32_t index, float x, float y, float z) { + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + + alSource3f(Sources[index], AL_POSITION, x, y, z); + if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; + } + + + ALboolean openal_playsound (uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Play sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePlay(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to play sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_pausesound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Pause sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourcePause(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", index) != AL_TRUE) + return AL_FALSE; + + return AL_TRUE; + } + + + ALboolean openal_stopsound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Stop sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + alSourceStop(Sources[index]); + if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", index) != AL_TRUE) + return AL_FALSE; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + + + ALboolean openal_freesound(uint32_t index){ + if (openalReady == AL_FALSE) { + errno = EPERM; + err_ret("(%s) WARN - OpenAL not initialized", prog); + return AL_FALSE; + } + + /*Stop sound number index*/ + if (index >= globalsize) { + errno = EINVAL; + err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); + return AL_FALSE; + } + globalindex--; + + alGetError(); /* clear any AL errors beforehand */ + + return AL_TRUE; + } + +#ifdef __CPLUSPLUS +} +#endif diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/openalbridge.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/openalbridge.def Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,17 @@ +LIBRARY "openalbridge" +EXPORTS + openal_init + openal_close + openal_ready + openal_loadfile + openal_toggleloop + openal_setvolume + openal_setglobalvolume + openal_togglemute + openal_fadeout + openal_fadein + openal_fade + openal_playsound + openal_pausesound + openal_stopsound + diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/openalbridge.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/openalbridge.h Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,48 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#ifndef _OALB_INTERFACE_H +#define _OALB_INTERFACE_H + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + char openal_init (char* programname, char usehardware, unsigned int memorysize); + char openal_close (void); + char openal_ready (void); + int openal_loadfile (const char *filename); + char openal_toggleloop (unsigned int index); + char openal_setposition (unsigned int index, float x, float y, float z); + char openal_setvolume (unsigned int index, unsigned char percentage); + char openal_setglobalvolume (unsigned char percentage); + char openal_togglemute (void); + char openal_fadeout (unsigned int index, unsigned short int quantity); + char openal_fadein (unsigned int index, unsigned short int quantity); + char openal_fade (unsigned int index, unsigned short int quantity, char direction); + char openal_playsound (unsigned int index); + char openal_pausesound (unsigned int index); + char openal_stopsound (unsigned int index); + char openal_freesound (unsigned int index); + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_OALB_INTERFACE_H*/ diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/wrappers.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/wrappers.c Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,165 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#include "wrappers.h" + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + extern ALint *Sources; + + void *Malloc (size_t nbytes) { + void *aptr; + + if ((aptr = malloc(nbytes)) == NULL) + err_dump("(%s) FATAL - not enough memory"); + + return aptr; + } + + + void *Realloc (void *aptr, size_t nbytes) { + aptr = realloc(aptr, nbytes); + + if (aptr == NULL) + err_dump("(%s) FATAL - not enough memory"); + + return aptr; + } + + + FILE *Fopen (const char *fname, char *mode) { + FILE *fp; + + fp = fopen(fname,mode); + if (fp == NULL) + err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode); + + return fp; + } + + /*TODO make a proper error reporting routine*/ + ALint AlGetError (const char *str) { + ALenum error; + + error = alGetError(); + if (error != AL_NO_ERROR) { + err_msg(str, prog); + return error; + } else + return AL_TRUE; + } + + ALint AlGetError2 (const char *str, int num) { + ALenum error; + + error = alGetError(); + if (error != AL_NO_ERROR) { + err_msg(str, prog, num); + return error; + } else + return AL_TRUE; + } + + void *helper_fadein(void *tmp) { + ALfloat gain; + ALfloat target_gain; + fade_t *fade; + uint32_t index; + uint16_t quantity; + + fade = tmp; + index = fade->index; + quantity = fade->quantity; + free (fade); + +#ifdef DEBUG + err_msg("(%s) INFO - Fade-in in progress [index %d quantity %d]", prog, index, quantity); +#endif + + /*save the volume desired after the fade*/ + alGetSourcef(Sources[index], AL_GAIN, &target_gain); + if (target_gain > 1.0f || target_gain <= 0.0f) + target_gain = 1.0f; + + alSourcePlay(Sources[index]); + + for (gain = 0.0f ; gain <= target_gain; gain += (float) quantity/10000) { +#ifdef TRACE + err_msg("(%s) DEBUG - Fade-in set gain to %f", gain); +#endif + alSourcef(Sources[index], AL_GAIN, gain); + usleep(10000); + } + + AlGetError("(%s) WARN - Failed to set fade-in volume level"); + +#ifndef _WIN32 + pthread_exit(NULL); +#else + _endthread(); +#endif + return 0; + } + + void *helper_fadeout(void *tmp) { + ALfloat gain; + ALfloat old_gain; + fade_t *fade; + uint32_t index; + uint16_t quantity; + + fade = tmp; + index = fade->index; + quantity = fade->quantity; + free(fade); + +#ifdef DEBUG + err_msg("(%s) INFO - Fade-out in progress [index %d quantity %d]", prog, index, quantity); +#endif + + alGetSourcef(Sources[index], AL_GAIN, &old_gain); + + for (gain = old_gain; gain >= 0.00f; gain -= (float) quantity/10000) { +#ifdef TRACE + err_msg("(%s) DEBUG - Fade-out set gain to %f", gain); +#endif + alSourcef(Sources[index], AL_GAIN, gain); + usleep(10000); + } + + AlGetError("(%s) WARN - Failed to set fade-out volume level"); + + /*stop that sound and reset its volume*/ + alSourceStop (Sources[index]); + alSourcef (Sources[index], AL_GAIN, old_gain); + +#ifndef _WIN32 + pthread_exit(NULL); +#else + _endthread(); +#endif + return 0; + } + + +#ifdef __CPLUSPLUS +} +#endif diff -r ac5d14a35482 -r a767dd3786b5 misc/openalbridge/wrappers.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/misc/openalbridge/wrappers.h Sat Apr 17 08:30:34 2010 +0000 @@ -0,0 +1,41 @@ +/* + * OpenAL Bridge - a simple portable library for OpenAL interface + * Copyright (c) 2009 Vittorio Giovara + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; version 2 of the License + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +#ifndef _OALB_WRAPPERS_H +#define _OALB_WRAPPERS_H + +#include "globals.h" + + +#ifdef __CPLUSPLUS +extern "C" { +#endif + + void *Malloc (size_t nbytes); + void *Realloc (void *aptr, size_t nbytes); + FILE *Fopen (const char *fname, char *mode); + ALint AlGetError (const char *str); + ALint AlGetError2 (const char *str, int num); + void *helper_fadein (void *tmp); + void *helper_fadeout (void *tmp); + +#ifdef __CPLUSPLUS +} +#endif + +#endif /*_OALB_WRAPPERS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/CMakeLists.txt --- a/openalbridge/CMakeLists.txt Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,41 +0,0 @@ -find_package(OpenAL REQUIRED) -find_package(OggVorbis REQUIRED) -include_directories(${OPENAL_INCLUDE_DIR}) -include_directories(${OGGVORBIS_INCLUDE_DIRS}) - -#set destination directory for library -set(LIBRARY_OUTPUT_PATH ${EXECUTABLE_OUTPUT_PATH}) - -#list of source files for libraries -set(openal_src - openalbridge.c loaders.c wrappers.c errlib.c -) - -#build a static library for human systems -set (build_type STATIC) - -#visualstudio and windows in general doesn't like static linking, so we're building the library in shared mode -if(WIN32) -#workaround for visualstudio (wants headers in the source list) - set(openal_src - openalbridge.h loaders.h wrappers.h globals.h oggvorbis.h errlib.h ${openal_src} - ) -#deps for the shared library - link_libraries(${VORBISFILE_LIBRARY}) - link_libraries(${VORBIS_LIBRARY}) - link_libraries(${OGG_LIBRARY}) - link_libraries(${OPENAL_LIBRARY}) -#build a shared library - set (build_type SHARED) -endif() - -#compiles and links actual library -add_library (openalbridge ${build_type} ${openal_src}) - -if(WIN32) -if(MSVC) - SET_TARGET_PROPERTIES(openalbridge PROPERTIES LINK_FLAGS /DEF:openalbridge.def) -endif(MSVC) -#install it in the executable directory - install(TARGETS openalbridge DESTINATION bin) -endif(WIN32) diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/errlib.c --- a/openalbridge/errlib.c Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,96 +0,0 @@ -/* - - module: errlib.c - - purpose: library of error functions - - reference: Stevens, Unix network programming (2ed), p.922 - - */ - -#include "errlib.h" - - -#define MAXLINE 4095 - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - int daemon_proc = 0; /* set to 0 if stdout/stderr available, else set to 1 */ - - static void err_doit (int errnoflag, int level, const char *fmt, va_list ap) - { - int errno_save = errno, n; - char buf[MAXLINE+1]; - - vsnprintf (buf, MAXLINE, fmt, ap); - n = strlen(buf); - if (errnoflag) - snprintf (buf+n, MAXLINE-n, ": %s", strerror(errno_save)); - strcat (buf, "\n"); - - if (daemon_proc) - syslog (level, buf); - else { - fflush (stdout); - fprintf (stderr, buf); - fflush (stderr); - } - - return; - } - - void err_ret (const char *fmt, ...) - { - va_list ap; - - va_start (ap, fmt); - err_doit (1, LOG_INFO, fmt, ap); - va_end (ap); - return; - } - - void err_sys (const char *fmt, ...) - { - va_list ap; - - va_start (ap, fmt); - err_doit (1, LOG_ERR, fmt, ap); - va_end (ap); - exit (1); - } - - void err_msg (const char *fmt, ...) - { - va_list ap; - - va_start (ap, fmt); - err_doit (0, LOG_INFO, fmt, ap); - va_end (ap); - return; - } - - void err_quit (const char *fmt, ...) - { - va_list ap; - - va_start (ap, fmt); - err_doit (0, LOG_ERR, fmt, ap); - va_end (ap); - exit (1); - } - - void err_dump (const char *fmt, ...) - { - va_list ap; - - va_start (ap, fmt); - err_doit (1, LOG_ERR, fmt, ap); - va_end (ap); - abort(); - } - -#ifdef __CPLUSPLUS -} -#endif diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/errlib.h --- a/openalbridge/errlib.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,43 +0,0 @@ -/* - - module: errlib.h - - purpose: definitions of function sin errlib.c - - reference: Stevens, Unix network programming (2ed), p.922 - - */ - -#ifndef _ERRLIB_H -#define _ERRLIB_H - -#include "globals.h" - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - extern int daemon_proc; - - void err_msg (const char *fmt, ...); - void err_quit (const char *fmt, ...); - void err_ret (const char *fmt, ...); - void err_sys (const char *fmt, ...); - void err_dump (const char *fmt, ...); - -#ifdef __CPLUSPLUS -} -#endif - -#endif /*_ERRLIB_H*/ - -/* - suggested error string ( PROG ) LEVEL - TEXT : ERRNO - - errno? closeprog? log level - err_msg no no LOG_INFO - err_quit no exit(1) LOG_ERR - err_ret si no LOG_INFO - err_sys si exit(1) LOG_ERR - err_dump si abort( ) LOG_ERR - */ \ No newline at end of file diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/globals.h --- a/openalbridge/globals.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,154 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#ifndef _OALB_GLOBALS_H -#define _OALB_GLOBALS_H - -#include -#include -#include -#include -#include -#include - -#ifndef _WIN32 -#include -#include -#else -#include -#define syslog(x,y) fprintf(stderr,y) -#define LOG_INFO 6 -#define LOG_ERR 3 -#endif - -#include "al.h" -#include "errlib.h" - - -/*control debug verbosity*/ -#ifdef TRACE -#ifndef DEBUG -#define DEBUG -#endif -#endif - -/** 1.0 02/03/10 - Defines cross-platform sleep, usleep, etc. [Wu Yongwei] **/ -#ifndef _SLEEP_H -#define _SLEEP_H -#ifdef _WIN32 -# if defined(_NEED_SLEEP_ONLY) && (defined(_MSC_VER) || defined(__MINGW32__)) -# include -# define sleep(t) _sleep((t) * 1000) -# else -# define WIN32_LEAN_AND_MEAN -# include -# define sleep(t) Sleep((t) * 1000) -# endif -# ifndef _NEED_SLEEP_ONLY -# define msleep(t) Sleep(t) -# define usleep(t) Sleep((t) / 1000) -# endif -#else -# include -# ifndef _NEED_SLEEP_ONLY -# define msleep(t) usleep((t) * 1000) -# endif -#endif -#endif /* _SLEEP_H */ - - -/* check compiler requirements */ /*FIXME*/ -#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) -#warning __BIG_ENDIAN__ or __LITTLE_ENDIAN__ not found, going to set __LITTLE_ENDIAN__ as default -#define __LITTLE_ENDIAN__ 1 -//#error Do not know the endianess of this architecture -#endif - -/* use byteswap macros from the host system, hopefully optimized ones ;-) - * or define our own version, simple, stupid, straight-forward... */ -#ifdef HAVE_BYTESWAP_H -#include -#else -#define bswap_16(x) ((((x) & 0xFF00) >> 8) | (((x) & 0x00FF) << 8)) -#define bswap_32(x) ((((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | \ -(((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) ) -#endif /* HAVE_BYTESWAP_H */ - -/* swap numbers accordingly to architecture automatically */ -#ifdef __LITTLE_ENDIAN__ -#define ENDIAN_LITTLE_32(x) x -#define ENDIAN_BIG_32(x) bswap_32(x) -#define ENDIAN_LITTLE_16(x) x -#define ENDIAN_BIG_16(x) bswap_16(x) -#elif __BIG_ENDIAN__ -#define ENDIAN_LITTLE_32(x) bswap_32(x) -#define ENDIAN_BIG_32(x) x -#define ENDIAN_LITTLE_16(x) bswap_16(x) -#define ENDIAN_BIG_16(x) x -#endif - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - /*data type for WAV header*/ -#pragma pack(1) - typedef struct _WAV_header_t { - uint32_t ChunkID; - uint32_t ChunkSize; - uint32_t Format; - uint32_t Subchunk1ID; - uint32_t Subchunk1Size; - uint16_t AudioFormat; - uint16_t NumChannels; - uint32_t SampleRate; - uint32_t ByteRate; - uint16_t BlockAlign; - uint16_t BitsPerSample; - uint32_t Subchunk2ID; - uint32_t Subchunk2Size; - } WAV_header_t; -#pragma pack() - - /*data type for passing data between threads*/ -#pragma pack(1) - typedef struct _fade_t { - uint32_t index; - uint16_t quantity; - } fade_t; -#pragma pack() - - - /*file format defines*/ -#define OGG_FILE_FORMAT 0x4F676753 -#define WAV_FILE_FORMAT 0x52494646 -#define WAV_HEADER_SUBCHUNK2ID 0x64617461 - - - /*other defines*/ -#define FADE_IN 0 -#define FADE_OUT 1 - - char *prog; - -#ifdef __CPLUSPLUS -} -#endif - -#endif /*_OALB_GLOBALS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/loaders.c --- a/openalbridge/loaders.c Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,247 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#include "loaders.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - int load_wavpcm (const char *filename, ALenum *format, char ** data, ALsizei *bitsize, ALsizei *freq) { - WAV_header_t WAVHeader; - FILE *wavfile; - int32_t t; - uint32_t n = 0; - uint8_t sub0, sub1, sub2, sub3; - - wavfile = Fopen(filename, "rb"); - - fread(&WAVHeader.ChunkID, sizeof(uint32_t), 1, wavfile); /*RIFF*/ - fread(&WAVHeader.ChunkSize, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.Format, sizeof(uint32_t), 1, wavfile); /*WAVE*/ - -#ifdef DEBUG - fprintf(stderr, "ChunkID: %X\n", ENDIAN_BIG_32(WAVHeader.ChunkID)); - fprintf(stderr, "ChunkSize: %d\n", ENDIAN_LITTLE_32(WAVHeader.ChunkSize)); - fprintf(stderr, "Format: %X\n", ENDIAN_BIG_32(WAVHeader.Format)); -#endif - - fread(&WAVHeader.Subchunk1ID, sizeof(uint32_t), 1, wavfile); /*fmt */ - fread(&WAVHeader.Subchunk1Size, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.AudioFormat, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.NumChannels, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.SampleRate, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.ByteRate, sizeof(uint32_t), 1, wavfile); - fread(&WAVHeader.BlockAlign, sizeof(uint16_t), 1, wavfile); - fread(&WAVHeader.BitsPerSample, sizeof(uint16_t), 1, wavfile); - -#ifdef DEBUG - fprintf(stderr, "Subchunk1ID: %X\n", ENDIAN_BIG_32(WAVHeader.Subchunk1ID)); - fprintf(stderr, "Subchunk1Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk1Size)); - fprintf(stderr, "AudioFormat: %d\n", ENDIAN_LITTLE_16(WAVHeader.AudioFormat)); - fprintf(stderr, "NumChannels: %d\n", ENDIAN_LITTLE_16(WAVHeader.NumChannels)); - fprintf(stderr, "SampleRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.SampleRate)); - fprintf(stderr, "ByteRate: %d\n", ENDIAN_LITTLE_32(WAVHeader.ByteRate)); - fprintf(stderr, "BlockAlign: %d\n", ENDIAN_LITTLE_16(WAVHeader.BlockAlign)); - fprintf(stderr, "BitsPerSample: %d\n", ENDIAN_LITTLE_16(WAVHeader.BitsPerSample)); -#endif - - /*remove useless header chunks by looking for the WAV_HEADER_SUBCHUNK2ID integer */ - do { - t = fread(&sub0, sizeof(uint8_t), 1, wavfile); - if(sub0 == 0x64) { - t = fread(&sub1, sizeof(uint8_t), 1, wavfile); - if(sub1 == 0x61) { - t = fread(&sub2, sizeof(uint8_t), 1, wavfile); - if(sub2 == 0x74) { - t = fread(&sub3, sizeof(uint8_t), 1, wavfile); - if(sub3 == 0x61) { - WAVHeader.Subchunk2ID = WAV_HEADER_SUBCHUNK2ID; - break; - } - } - } - } - - if (t <= 0) { - /*eof*/ - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header", prog); - return AL_FALSE; - } - } while (1); - - fread(&WAVHeader.Subchunk2Size, sizeof(uint32_t), 1, wavfile); - -#ifdef DEBUG - fprintf(stderr, "Subchunk2ID: %X\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2ID)); - fprintf(stderr, "Subchunk2Size: %d\n", ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); -#endif - - *data = (char*) Malloc (sizeof(char) * ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); - - /*read the actual sound data*/ - do { - n += fread(&((*data)[n]), sizeof(uint8_t), 4, wavfile); - } while (n < ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size)); - - fclose(wavfile); - -#ifdef DEBUG - err_msg("(%s) INFO - WAV data loaded", prog); -#endif - - /*set parameters for OpenAL*/ - /*Valid formats are AL_FORMAT_MONO8, AL_FORMAT_MONO16, AL_FORMAT_STEREO8, and AL_FORMAT_STEREO16*/ - if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 1) { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) - *format = AL_FORMAT_MONO8; - else { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) - *format = AL_FORMAT_MONO16; - else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); - return AL_FALSE; - } - } - } else { - if (ENDIAN_LITTLE_16(WAVHeader.NumChannels) == 2) { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 8) - *format = AL_FORMAT_STEREO8; - else { - if (ENDIAN_LITTLE_16(WAVHeader.BitsPerSample) == 16) - *format = AL_FORMAT_STEREO16; - else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header [bitsample value]", prog); - return AL_FALSE; - } - } - } else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong WAV header [format value]", prog); - return AL_FALSE; - } - } - - *bitsize = ENDIAN_LITTLE_32(WAVHeader.Subchunk2Size); - *freq = ENDIAN_LITTLE_32(WAVHeader.SampleRate); - return AL_TRUE; - } - - - int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq) { - /*implementation inspired from http://www.devmaster.net/forums/showthread.php?t=1153 */ - - /*stream handle*/ - OggVorbis_File oggStream; - /*some formatting data*/ - vorbis_info *vorbisInfo; - /*length of the decoded data*/ - int64_t pcm_length; - /*other vars*/ - int section, result, size, endianness; -#ifdef DEBUG - int i; - /*other less useful data*/ - vorbis_comment *vorbisComment; -#endif - - result = ov_fopen((char*) filename, &oggStream); - if (result < 0) { - errno = EINVAL; - err_ret("(%s) ERROR - ov_fopen() failed with %X", prog, result); - ov_clear(&oggStream); - return AL_FALSE; - } - - /*load OGG header and determine the decoded data size*/ - vorbisInfo = ov_info(&oggStream, -1); - pcm_length = ov_pcm_total(&oggStream, -1) << vorbisInfo->channels; - -#ifdef DEBUG - vorbisComment = ov_comment(&oggStream, -1); - fprintf(stderr, "Version: %d\n", vorbisInfo->version); - fprintf(stderr, "Channels: %d\n", vorbisInfo->channels); - fprintf(stderr, "Rate (Hz): %ld\n", vorbisInfo->rate); - fprintf(stderr, "Bitrate Upper: %ld\n", vorbisInfo->bitrate_upper); - fprintf(stderr, "Bitrate Nominal: %ld\n", vorbisInfo->bitrate_nominal); - fprintf(stderr, "Bitrate Lower: %ld\n", vorbisInfo->bitrate_lower); - fprintf(stderr, "Bitrate Windows: %ld\n", vorbisInfo->bitrate_window); - fprintf(stderr, "Vendor: %s\n", vorbisComment->vendor); - fprintf(stderr, "PCM data size: %lld\n", pcm_length); - fprintf(stderr, "# comment: %d\n", vorbisComment->comments); - for (i = 0; i < vorbisComment->comments; i++) - fprintf(stderr, "\tComment %d: %s\n", i, vorbisComment->user_comments[i]); -#endif - - /*allocates enough room for the decoded data*/ - *data = (char*) Malloc (sizeof(char) * pcm_length); - - /*there *should* not be ogg at 8 bits*/ - if (vorbisInfo->channels == 1) - *format = AL_FORMAT_MONO16; - else { - if (vorbisInfo->channels == 2) - *format = AL_FORMAT_STEREO16; - else { - errno = EILSEQ; - err_ret("(%s) ERROR - wrong OGG header [channel %d]", prog, vorbisInfo->channels); - ov_clear(&oggStream); - return AL_FALSE; - } - } - - size = 0; -#ifdef __LITTLE_ENDIAN__ - endianness = 0; -#elif __BIG_ENDIAN__ - endianness = 1; -#endif - while (size < pcm_length) { - /*ov_read decodes the ogg stream and storse the pcm in data*/ - result = ov_read (&oggStream, *data + size, pcm_length - size, endianness, 2, 1, §ion); - if (result > 0) { - size += result; - } else { - if (result == 0) - break; - else { - errno = EILSEQ; - err_ret("(%s) ERROR - End of file from OGG stream", prog); - ov_clear(&oggStream); - return AL_FALSE; - } - } - } - - /*set the last fields*/ - *bitsize = size; - *freq = vorbisInfo->rate; - - /*cleaning time*/ - ov_clear(&oggStream); - - return AL_TRUE; - } - -#ifdef __CPLUSPLUS -} -#endif diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/loaders.h --- a/openalbridge/loaders.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,38 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#ifndef _OALB_LOADERS_H -#define _OALB_LOADERS_H - -#include "globals.h" -#include "wrappers.h" -#include "oggvorbis.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - int load_wavpcm (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); - int load_oggvorbis (const char *filename, ALenum *format, char **data, ALsizei *bitsize, ALsizei *freq); - -#ifdef __CPLUSPLUS -} -#endif - -#endif /*_OALB_LOADERS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/oggvorbis.h --- a/openalbridge/oggvorbis.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,175 +0,0 @@ -/******************************************************************** - * * - * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * - * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * - * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * - * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * - * * - * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 * - * by the Xiph.Org Foundation http://www.xiph.org/ * - * * - ********************************************************************/ - -#ifndef _OGGVORBIS_H -#define _OGGVORBIS_H - -/*data types for ogg and vorbis that are required to be external*/ -#ifndef ogg_int64_t -#define ogg_int64_t int64_t -#endif - -typedef struct { - unsigned char *data; - int storage; - int fill; - int returned; - int unsynced; - int headerbytes; - int bodybytes; -} ogg_sync_state; -typedef struct vorbis_info{ - int version; - int channels; - long rate; - /* The below bitrate declarations are *hints*. - Combinations of the three values carry the following implications: all three set to the same value: implies a fixed rate bitstream - only nominal set: implies a VBR stream that averages the nominal bitrate. No hard upper/lower limit - upper and or lower set: implies a VBR bitstream that obeys the bitrate limits. nominal may also be set to give a nominal rate. - none set: the coder does not care to speculate. */ - long bitrate_upper; - long bitrate_nominal; - long bitrate_lower; - long bitrate_window; - void *codec_setup; -} vorbis_info; -typedef struct vorbis_comment{ - /* unlimited user comment fields. libvorbis writes 'libvorbis' whatever vendor is set to in encode */ - char **user_comments; - int *comment_lengths; - int comments; - char *vendor; -} vorbis_comment; -typedef struct { - unsigned char *body_data; /* bytes from packet bodies */ - long body_storage; /* storage elements allocated */ - long body_fill; /* elements stored; fill mark */ - long body_returned; /* elements of fill returned */ - int *lacing_vals; /* The values that will go to the segment table */ - ogg_int64_t *granule_vals; - /* granulepos values for headers. Not compact this way, but it is simple coupled to the lacing fifo */ - long lacing_storage; - long lacing_fill; - long lacing_packet; - long lacing_returned; - unsigned char header[282]; /* working space for header encode */ - int header_fill; - int e_o_s; /* set when we have buffered the last packet in the logical bitstream */ - int b_o_s; /* set after we've written the initial page of a logical bitstream */ - long serialno; - long pageno; - ogg_int64_t packetno; - /* sequence number for decode; the framing knows where there's a hole in the data, - but we need coupling so that the codec (which is in a seperate abstraction layer) also knows about the gap */ - ogg_int64_t granulepos; -} ogg_stream_state; -typedef struct vorbis_dsp_state{ - int analysisp; - vorbis_info *vi; - float **pcm; - float **pcmret; - int pcm_storage; - int pcm_current; - int pcm_returned; - int preextrapolate; - int eofflag; - long lW; - long W; - long nW; - long centerW; - ogg_int64_t granulepos; - ogg_int64_t sequence; - ogg_int64_t glue_bits; - ogg_int64_t time_bits; - ogg_int64_t floor_bits; - ogg_int64_t res_bits; - void *backend_state; -} vorbis_dsp_state; -typedef struct { - long endbyte; - int endbit; - unsigned char *buffer; - unsigned char *ptr; - long storage; -} oggpack_buffer; -typedef struct vorbis_block{ - /* necessary stream state for linking to the framing abstraction */ - float **pcm; /* this is a pointer into local storage */ - oggpack_buffer opb; - long lW; - long W; - long nW; - int pcmend; - int mode; - int eofflag; - ogg_int64_t granulepos; - ogg_int64_t sequence; - vorbis_dsp_state *vd; /* For read-only access of configuration */ - /* local storage to avoid remallocing; it's up to the mapping to structure it */ - void *localstore; - long localtop; - long localalloc; - long totaluse; - struct alloc_chain *reap; - /* bitmetrics for the frame */ - long glue_bits; - long time_bits; - long floor_bits; - long res_bits; - void *internal; -} vorbis_block; -typedef struct { - size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); - int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); - int (*close_func) (void *datasource); - long (*tell_func) (void *datasource); -} ov_callbacks; -typedef struct OggVorbis_File { - void *datasource; /* Pointer to a FILE *, etc. */ - int seekable; - ogg_int64_t offset; - ogg_int64_t end; - ogg_sync_state oy; - /* If the FILE handle isn't seekable (eg, a pipe), only the current stream appears */ - int links; - ogg_int64_t *offsets; - ogg_int64_t *dataoffsets; - long *serialnos; - ogg_int64_t *pcmlengths; - /* overloaded to maintain binary - compatability; x2 size, stores both - beginning and end values */ - vorbis_info *vi; - vorbis_comment *vc; - /* Decoding working state local storage */ - ogg_int64_t pcm_offset; - int ready_state; - long current_serialno; - int current_link; - double bittrack; - double samptrack; - ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */ - vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ - vorbis_block vb; /* local working space for packet->PCM decode */ - ov_callbacks callbacks; -} OggVorbis_File; - - -extern int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes); -extern int ov_fopen(char *path,OggVorbis_File *vf); -extern long ov_read(OggVorbis_File *vf,char *buffer,int length,int bigendianp,int word,int sgned,int *bitstream); -extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); -extern vorbis_info *ov_info(OggVorbis_File *vf,int link); -extern vorbis_comment *ov_comment(OggVorbis_File *f, int num); -extern int ov_clear(OggVorbis_File *vf); - -#endif /*_OGGVORBIS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/openalbridge.c --- a/openalbridge/openalbridge.c Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,498 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#include "openalbridge.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - /*Sources are points emitting sound*/ - ALuint *Sources; - /*Buffers hold sound data*/ - ALuint *Buffers; - /*index for Sources and Buffers*/ - ALuint globalindex, globalsize, increment; - - ALboolean openalReady = AL_FALSE; - - ALboolean openal_close (void) { - /*Stop all sounds, deallocate all memory and close OpenAL */ - ALCcontext *context; - ALCdevice *device; - - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - alSourceStopv (globalsize, Sources); - alDeleteSources (globalsize, Sources); - alDeleteBuffers (globalsize, Buffers); - - free(Sources); - free(Buffers); - - context = alcGetCurrentContext(); - device = alcGetContextsDevice(context); - - alcMakeContextCurrent(NULL); - alcDestroyContext(context); - alcCloseDevice(device); - - openalReady = AL_FALSE; - - return AL_TRUE; - } - - ALboolean openal_ready(void) { - return openalReady; - } - - ALboolean openal_init(char* programname, ALboolean usehardware, uint32_t memorysize) { - /*Initialize an OpenAL contex and allocate memory space for data and buffers*/ - ALCcontext *context; - ALCdevice *device; - const ALCchar *default_device; - - prog = programname; - - /*Position of the listener*/ - ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 }; - /*Velocity of the listener*/ - ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 }; - /*Orientation of the listener. (first 3 elements are "at", second 3 are "up")*/ - ALfloat ListenerOri[] = { 0.0, 0.0, -1.0, 0.0, 1.0, 0.0 }; - - if (openalReady == AL_TRUE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL already initialized", prog); - return AL_FALSE; - } - - if (usehardware == AL_TRUE) - device = alcOpenDevice(NULL); - else - device = alcOpenDevice("Generic Software"); - - if (device == NULL) { - errno = ENODEV; - err_ret("(%s) WARN - Failed to open sound device", prog); - return AL_FALSE; - } - err_msg("(%s) INFO - Output device: %s", prog, alcGetString(device, ALC_DEVICE_SPECIFIER)); - - context = alcCreateContext(device, NULL); - alcMakeContextCurrent(context); - alcProcessContext(context); - - if (AlGetError("(%s) WARN - Failed to create a new contex") != AL_TRUE) - return AL_FALSE; - - /*allocate memory space for buffers and sources*/ - if (memorysize == 0) - globalsize = 50; - else - globalsize = memorysize; - increment = globalsize; - - Buffers = (ALuint*) Malloc(sizeof(ALuint)*globalsize); - Sources = (ALuint*) Malloc(sizeof(ALuint)*globalsize); - - /*set the listener gain, position (on xyz axes), velocity (one value for each axe) and orientation*/ - alListenerf (AL_GAIN, 1.0f ); - alListenerfv(AL_POSITION, ListenerPos); - alListenerfv(AL_VELOCITY, ListenerVel); - alListenerfv(AL_ORIENTATION, ListenerOri); - - if (AlGetError("(%s) WARN - Failed to set Listener properties") != AL_TRUE) - return AL_FALSE; - - openalReady = AL_TRUE; - - alGetError(); /* clear any AL errors beforehand */ - return AL_TRUE; - } - - - ALboolean helper_realloc (void) { - /*expands allocated memory when loading more sound files than expected*/ - int oldsize = globalsize; - globalsize += increment; - -#ifdef DEBUG - err_msg("(%s) INFO - Realloc in process from %d to %d\n", prog, oldsize, globalsize); -#endif - - Buffers = (ALuint*) Realloc(Buffers, sizeof(ALuint)*globalsize); - Sources = (ALuint*) Realloc(Sources, sizeof(ALuint)*globalsize); - - return AL_TRUE; - } - - - ALint openal_loadfile (const char *filename){ - /*Open a file, load into memory and allocate the Source buffer for playing*/ - ALfloat SourcePos[] = { 0.0, 0.0, 0.0 }; /*Position of the source sound*/ - ALfloat SourceVel[] = { 0.0, 0.0, 0.0 }; /*Velocity of the source sound*/ - ALenum format; - ALsizei bitsize, freq; - char *data; - uint32_t fileformat; - ALenum error; - FILE *fp; - - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*when the buffers are all used, we can expand memory to accept new files*/ - if (globalindex == globalsize) - helper_realloc(); - - /*detect the file format, as written in the first 4 bytes of the header*/ - fp = Fopen (filename, "rb"); - - if (fp == NULL) - return -1; - - error = fread (&fileformat, sizeof(uint32_t), 1, fp); - fclose (fp); - - if (error < 0) { - errno = EIO; - err_ret("(%s) ERROR - File %s is too short", prog, filename); - return -2; - } - - /*prepare the buffer to receive data*/ - alGenBuffers(1, &Buffers[globalindex]); - - if (AlGetError("(%s) ERROR - Failed to allocate memory for buffers") != AL_TRUE) - return -3; - - /*prepare the source to emit sound*/ - alGenSources(1, &Sources[globalindex]); - - if (AlGetError("(%s) ERROR - Failed to allocate memory for sources") != AL_TRUE) - return -4; - - - switch (ENDIAN_BIG_32(fileformat)) { - case OGG_FILE_FORMAT: - error = load_oggvorbis (filename, &format, &data, &bitsize, &freq); - break; - case WAV_FILE_FORMAT: - error = load_wavpcm (filename, &format, &data, &bitsize, &freq); - break; - default: - errno = EINVAL; - err_ret ("(%s) ERROR - File format (%08X) not supported", prog, ENDIAN_BIG_32(fileformat)); - return -5; - break; - } - - - /*copy pcm data in one buffer*/ - alBufferData(Buffers[globalindex], format, data, bitsize, freq); - free(data); /*deallocate data to save memory*/ - - if (AlGetError("(%s) ERROR - Failed to write data to buffers") != AL_TRUE) - return -6; - - /*set source properties that it will use when it's in playback*/ - alSourcei (Sources[globalindex], AL_BUFFER, Buffers[globalindex] ); - alSourcef (Sources[globalindex], AL_PITCH, 1.0f ); - alSourcef (Sources[globalindex], AL_GAIN, 1.0f ); - alSourcefv(Sources[globalindex], AL_POSITION, SourcePos ); - alSourcefv(Sources[globalindex], AL_VELOCITY, SourceVel ); - alSourcei (Sources[globalindex], AL_LOOPING, 0 ); - - if (AlGetError("(%s) ERROR - Failed to set Source properties") != AL_TRUE) - return -7; - - alGetError(); /* clear any AL errors beforehand */ - - /*returns the index of the source you just loaded, increments it and exits*/ - return globalindex++; - } - - - ALboolean openal_toggleloop (uint32_t index){ - /*Set or unset looping mode*/ - ALint loop; - - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - alGetSourcei (Sources[index], AL_LOOPING, &loop); - alSourcei (Sources[index], AL_LOOPING, !((uint8_t) loop) & 0x00000001); - if (AlGetError("(%s) ERROR - Failed to get or set loop property") != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_setvolume (uint32_t index, uint8_t percentage) { - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*Set volume for sound number index*/ - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - if (percentage > 100) - percentage = 100; - alSourcef (Sources[index], AL_GAIN, (float) percentage/100.0f); - if (AlGetError2("(%s) ERROR - Failed to set volume for sound %d\n", index) != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_setglobalvolume (uint8_t percentage) { - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*Set volume for all sounds*/ - if (percentage > 100) - percentage = 100; - alListenerf (AL_GAIN, (float) percentage/100.0f); - if (AlGetError("(%s) ERROR - Failed to set global volume") != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_togglemute () { - /*Mute or unmute sound*/ - ALfloat mute; - - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - alGetListenerf (AL_GAIN, &mute); - if (mute > 0) - mute = 0; - else - mute = 1.0; - alListenerf (AL_GAIN, mute); - if (AlGetError("(%s) ERROR - Failed to set mute property") != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_fade (uint32_t index, uint16_t quantity, ALboolean direction) { - /*Fade in or out by calling a helper thread*/ -#ifndef _WIN32 - pthread_t thread; -#else - HANDLE Thread; - DWORD threadID; -#endif - fade_t *fade; - - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - fade = (fade_t*) Malloc(sizeof(fade_t)); - fade->index = index; - fade->quantity = quantity; - - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - switch (direction) { - case FADE_IN: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadein, (void*) fade); -#else - Thread = _beginthread(&helper_fadein, 0, (void*) fade); -#endif - break; - case FADE_OUT: -#ifndef _WIN32 - pthread_create(&thread, NULL, helper_fadeout, (void*) fade); -#else - Thread = _beginthread(&helper_fadeout, 0, (void*) fade); -#endif - break; - default: - errno = EINVAL; - err_ret("(%s) ERROR - Unknown direction for fading", prog, index, globalindex); - free(fade); - return AL_FALSE; - break; - } - -#ifndef _WIN32 - pthread_detach(thread); -#endif - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_fadeout (uint32_t index, uint16_t quantity) { - /*wrapper for fadeout*/ - return openal_fade(index, quantity, FADE_OUT); - } - - - ALboolean openal_fadein (uint32_t index, uint16_t quantity) { - /*wrapper for fadein*/ - return openal_fade(index, quantity, FADE_IN); - } - - - ALboolean openal_setposition (uint32_t index, float x, float y, float z) { - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - - alSource3f(Sources[index], AL_POSITION, x, y, z); - if (AlGetError2("(%s) ERROR - Failed to set position for sound %d)", index) != AL_TRUE) - return AL_FALSE; - - return AL_TRUE; - } - - - ALboolean openal_playsound (uint32_t index){ - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*Play sound number index*/ - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - alSourcePlay(Sources[index]); - if (AlGetError2("(%s) ERROR - Failed to play sound %d)", index) != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - - - ALboolean openal_pausesound(uint32_t index){ - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*Pause sound number index*/ - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - alSourcePause(Sources[index]); - if (AlGetError2("(%s) ERROR - Failed to pause sound %d)", index) != AL_TRUE) - return AL_FALSE; - - return AL_TRUE; - } - - - ALboolean openal_stopsound(uint32_t index){ - if (openalReady == AL_FALSE) { - errno = EPERM; - err_ret("(%s) WARN - OpenAL not initialized", prog); - return AL_FALSE; - } - - /*Stop sound number index*/ - if (index >= globalsize) { - errno = EINVAL; - err_ret("(%s) ERROR - Index out of bounds (got %d, max %d)", prog, index, globalindex); - return AL_FALSE; - } - alSourceStop(Sources[index]); - if (AlGetError2("(%s) ERROR - Failed to stop sound %d)", index) != AL_TRUE) - return AL_FALSE; - - alGetError(); /* clear any AL errors beforehand */ - - return AL_TRUE; - } - -#ifdef __CPLUSPLUS -} -#endif diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/openalbridge.def --- a/openalbridge/openalbridge.def Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,17 +0,0 @@ -LIBRARY "openalbridge" -EXPORTS - openal_init - openal_close - openal_ready - openal_loadfile - openal_toggleloop - openal_setvolume - openal_setglobalvolume - openal_togglemute - openal_fadeout - openal_fadein - openal_fade - openal_playsound - openal_pausesound - openal_stopsound - diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/openalbridge.h --- a/openalbridge/openalbridge.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,52 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#ifndef _OALB_INTERFACE_H -#define _OALB_INTERFACE_H - -#include "globals.h" -#include "wrappers.h" -#include "alc.h" -#include "loaders.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - ALboolean openal_init (char* programname, ALboolean usehardware, unsigned int memorysize); - ALboolean openal_close (void); - ALboolean openal_ready (void); - ALint openal_loadfile (const char *filename); - ALboolean openal_toggleloop (unsigned int index); - ALboolean openal_setposition (unsigned int index, float x, float y, float z); - ALboolean openal_setvolume (unsigned int index, unsigned char percentage); - ALboolean openal_setglobalvolume (unsigned char percentage); - ALboolean openal_togglemute (void); - ALboolean openal_fadeout (unsigned int index, unsigned short int quantity); - ALboolean openal_fadein (unsigned int index, unsigned short int quantity); - ALboolean openal_fade (unsigned int index, unsigned short int quantity, ALboolean direction); - ALboolean openal_playsound (unsigned int index); - ALboolean openal_pausesound (unsigned int index); - ALboolean openal_stopsound (unsigned int index); - -#ifdef __CPLUSPLUS -} -#endif - -#endif /*_OALB_INTERFACE_H*/ diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/wrappers.c --- a/openalbridge/wrappers.c Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,165 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#include "wrappers.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - extern ALint *Sources; - - void *Malloc (size_t nbytes) { - void *aptr; - - if ((aptr = malloc(nbytes)) == NULL) - err_dump("(%s) FATAL - not enough memory"); - - return aptr; - } - - - void *Realloc (void *aptr, size_t nbytes) { - aptr = realloc(aptr, nbytes); - - if (aptr == NULL) - err_dump("(%s) FATAL - not enough memory"); - - return aptr; - } - - - FILE *Fopen (const char *fname, char *mode) { - FILE *fp; - - fp = fopen(fname,mode); - if (fp == NULL) - err_ret("(%s) ERROR - can't open file %s in mode '%s'", prog, fname, mode); - - return fp; - } - - /*TODO make a proper error reporting routine*/ - ALint AlGetError (const char *str) { - ALenum error; - - error = alGetError(); - if (error != AL_NO_ERROR) { - err_msg(str, prog); - return error; - } else - return AL_TRUE; - } - - ALint AlGetError2 (const char *str, int num) { - ALenum error; - - error = alGetError(); - if (error != AL_NO_ERROR) { - err_msg(str, prog, num); - return error; - } else - return AL_TRUE; - } - - void *helper_fadein(void *tmp) { - ALfloat gain; - ALfloat target_gain; - fade_t *fade; - uint32_t index; - uint16_t quantity; - - fade = tmp; - index = fade->index; - quantity = fade->quantity; - free (fade); - -#ifdef DEBUG - err_msg("(%s) INFO - Fade-in in progress [index %d quantity %d]", prog, index, quantity); -#endif - - /*save the volume desired after the fade*/ - alGetSourcef(Sources[index], AL_GAIN, &target_gain); - if (target_gain > 1.0f || target_gain <= 0.0f) - target_gain = 1.0f; - - alSourcePlay(Sources[index]); - - for (gain = 0.0f ; gain <= target_gain; gain += (float) quantity/10000) { -#ifdef TRACE - err_msg("(%s) DEBUG - Fade-in set gain to %f", gain); -#endif - alSourcef(Sources[index], AL_GAIN, gain); - usleep(10000); - } - - AlGetError("(%s) WARN - Failed to set fade-in volume level"); - -#ifndef _WIN32 - pthread_exit(NULL); -#else - _endthread(); -#endif - return 0; - } - - void *helper_fadeout(void *tmp) { - ALfloat gain; - ALfloat old_gain; - fade_t *fade; - uint32_t index; - uint16_t quantity; - - fade = tmp; - index = fade->index; - quantity = fade->quantity; - free(fade); - -#ifdef DEBUG - err_msg("(%s) INFO - Fade-out in progress [index %d quantity %d]", prog, index, quantity); -#endif - - alGetSourcef(Sources[index], AL_GAIN, &old_gain); - - for (gain = old_gain; gain >= 0.00f; gain -= (float) quantity/10000) { -#ifdef TRACE - err_msg("(%s) DEBUG - Fade-out set gain to %f", gain); -#endif - alSourcef(Sources[index], AL_GAIN, gain); - usleep(10000); - } - - AlGetError("(%s) WARN - Failed to set fade-out volume level"); - - /*stop that sound and reset its volume*/ - alSourceStop (Sources[index]); - alSourcef (Sources[index], AL_GAIN, old_gain); - -#ifndef _WIN32 - pthread_exit(NULL); -#else - _endthread(); -#endif - return 0; - } - - -#ifdef __CPLUSPLUS -} -#endif diff -r ac5d14a35482 -r a767dd3786b5 openalbridge/wrappers.h --- a/openalbridge/wrappers.h Sat Apr 17 04:59:10 2010 +0000 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,41 +0,0 @@ -/* - * OpenAL Bridge - a simple portable library for OpenAL interface - * Copyright (c) 2009 Vittorio Giovara - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU Lesser General Public License as published by - * the Free Software Foundation; version 2 of the License - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA - */ - -#ifndef _OALB_WRAPPERS_H -#define _OALB_WRAPPERS_H - -#include "globals.h" - - -#ifdef __CPLUSPLUS -extern "C" { -#endif - - void *Malloc (size_t nbytes); - void *Realloc (void *aptr, size_t nbytes); - FILE *Fopen (const char *fname, char *mode); - ALint AlGetError (const char *str); - ALint AlGetError2 (const char *str, int num); - void *helper_fadein (void *tmp); - void *helper_fadeout (void *tmp); - -#ifdef __CPLUSPLUS -} -#endif - -#endif /*_OALB_WRAPPERS_H*/ diff -r ac5d14a35482 -r a767dd3786b5 project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/project.pbxproj --- a/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/project.pbxproj Sat Apr 17 04:59:10 2010 +0000 +++ b/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/project.pbxproj Sat Apr 17 08:30:34 2010 +0000 @@ -122,6 +122,18 @@ 61A11AD61168DB3700359010 /* DetailViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 61A11AD51168DB3700359010 /* DetailViewController.m */; }; 61A11AE11168DC6E00359010 /* SingleTeamViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 61A11AE01168DC6E00359010 /* SingleTeamViewController.m */; }; 61A11AE41168DC9400359010 /* HogHatViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 61A11AE31168DC9400359010 /* HogHatViewController.m */; }; + 61C325431179A336001E70B1 /* errlib.c in Sources */ = {isa = PBXBuildFile; fileRef = 61C325391179A336001E70B1 /* errlib.c */; }; + 61C325441179A336001E70B1 /* errlib.h in Headers */ = {isa = PBXBuildFile; fileRef = 61C3253A1179A336001E70B1 /* errlib.h */; }; + 61C325451179A336001E70B1 /* globals.h in Headers */ = {isa = PBXBuildFile; fileRef = 61C3253B1179A336001E70B1 /* globals.h */; }; + 61C325461179A336001E70B1 /* loaders.c in Sources */ = {isa = PBXBuildFile; fileRef = 61C3253C1179A336001E70B1 /* loaders.c */; }; + 61C325471179A336001E70B1 /* loaders.h in Headers */ = {isa = PBXBuildFile; fileRef = 61C3253D1179A336001E70B1 /* loaders.h */; }; + 61C325481179A336001E70B1 /* openalbridge.c in Sources */ = {isa = PBXBuildFile; fileRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; }; + 61C325491179A336001E70B1 /* openalbridge.h in Headers */ = {isa = PBXBuildFile; fileRef = 61C325401179A336001E70B1 /* openalbridge.h */; }; + 61C3254A1179A336001E70B1 /* wrappers.c in Sources */ = {isa = PBXBuildFile; fileRef = 61C325411179A336001E70B1 /* wrappers.c */; }; + 61C3254B1179A336001E70B1 /* wrappers.h in Headers */ = {isa = PBXBuildFile; fileRef = 61C325421179A336001E70B1 /* wrappers.h */; }; + 61C3255B1179A384001E70B1 /* OpenAL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 61C3255A1179A384001E70B1 /* OpenAL.framework */; }; + 61C325901179A732001E70B1 /* OpenAL.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 61C3255A1179A384001E70B1 /* OpenAL.framework */; }; + 61C325A31179A7AD001E70B1 /* libopenalbridge.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 61C3251D1179A300001E70B1 /* libopenalbridge.a */; }; 61CE250D115E749A0098C467 /* OverlayViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = 61CE250C115E749A0098C467 /* OverlayViewController.m */; }; 922F64900F10F53100DC6EC0 /* libfpc.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 928301170F10CAFC00CC5A3C /* libfpc.a */; }; /* End PBXBuildFile section */ @@ -168,6 +180,13 @@ remoteGlobalIDString = BE48FD6E07AFA17000BB41DA; remoteInfo = "Static Library"; }; + 61C325201179A30E001E70B1 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 29B97313FDCFA39411CA2CEA /* Project object */; + proxyType = 1; + remoteGlobalIDString = 61C3251C1179A300001E70B1 /* openalbridge */; + remoteInfo = openalbridge; + }; 928301590F10E41300CC5A3C /* PBXContainerItemProxy */ = { isa = PBXContainerItemProxy; containerPortal = 29B97313FDCFA39411CA2CEA /* Project object */; @@ -309,6 +328,17 @@ 61A11AE01168DC6E00359010 /* SingleTeamViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = SingleTeamViewController.m; path = ../../cocoaTouch/SingleTeamViewController.m; sourceTree = SOURCE_ROOT; }; 61A11AE21168DC9400359010 /* HogHatViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = HogHatViewController.h; path = ../../cocoaTouch/HogHatViewController.h; sourceTree = SOURCE_ROOT; }; 61A11AE31168DC9400359010 /* HogHatViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = HogHatViewController.m; path = ../../cocoaTouch/HogHatViewController.m; sourceTree = SOURCE_ROOT; }; + 61C3251D1179A300001E70B1 /* libopenalbridge.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libopenalbridge.a; sourceTree = BUILT_PRODUCTS_DIR; }; + 61C325391179A336001E70B1 /* errlib.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = errlib.c; path = ../../misc/openalbridge/errlib.c; sourceTree = SOURCE_ROOT; }; + 61C3253A1179A336001E70B1 /* errlib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = errlib.h; path = ../../misc/openalbridge/errlib.h; sourceTree = SOURCE_ROOT; }; + 61C3253B1179A336001E70B1 /* globals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = globals.h; path = ../../misc/openalbridge/globals.h; sourceTree = SOURCE_ROOT; }; + 61C3253C1179A336001E70B1 /* loaders.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = loaders.c; path = ../../misc/openalbridge/loaders.c; sourceTree = SOURCE_ROOT; }; + 61C3253D1179A336001E70B1 /* loaders.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = loaders.h; path = ../../misc/openalbridge/loaders.h; sourceTree = SOURCE_ROOT; }; + 61C3253E1179A336001E70B1 /* openalbridge.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = openalbridge.c; path = ../../misc/openalbridge/openalbridge.c; sourceTree = SOURCE_ROOT; }; + 61C325401179A336001E70B1 /* openalbridge.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = openalbridge.h; path = ../../misc/openalbridge/openalbridge.h; sourceTree = SOURCE_ROOT; }; + 61C325411179A336001E70B1 /* wrappers.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = wrappers.c; path = ../../misc/openalbridge/wrappers.c; sourceTree = SOURCE_ROOT; }; + 61C325421179A336001E70B1 /* wrappers.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = wrappers.h; path = ../../misc/openalbridge/wrappers.h; sourceTree = SOURCE_ROOT; }; + 61C3255A1179A384001E70B1 /* OpenAL.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = OpenAL.framework; path = System/Library/Frameworks/OpenAL.framework; sourceTree = SDKROOT; }; 61CE250B115E749A0098C467 /* OverlayViewController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = OverlayViewController.h; path = ../../cocoaTouch/OverlayViewController.h; sourceTree = SOURCE_ROOT; }; 61CE250C115E749A0098C467 /* OverlayViewController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = OverlayViewController.m; path = ../../cocoaTouch/OverlayViewController.m; sourceTree = SOURCE_ROOT; }; 8D1107310486CEB800E47090 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; @@ -320,12 +350,14 @@ isa = PBXFrameworksBuildPhase; buildActionMask = 2147483647; files = ( + 61C325901179A732001E70B1 /* OpenAL.framework in Frameworks */, 61A1188511683A8C00359010 /* CoreGraphics.framework in Frameworks */, 61798A14114AB65C00BA94A9 /* libSDL_ttf.a in Frameworks */, 617989BE114AB47A00BA94A9 /* libSDL_net.a in Frameworks */, 617988DB114AAA4200BA94A9 /* libSDLiPhoneOS.a in Frameworks */, 61798996114AB3FF00BA94A9 /* libSDL_mixer.a in Frameworks */, 922F64900F10F53100DC6EC0 /* libfpc.a in Frameworks */, + 61C325A31179A7AD001E70B1 /* libopenalbridge.a in Frameworks */, 1D60589F0D05DD5A006BFB54 /* Foundation.framework in Frameworks */, 1DF5F4E00D08C38300B7A737 /* UIKit.framework in Frameworks */, 28FD15000DC6FC520079059D /* OpenGLES.framework in Frameworks */, @@ -339,6 +371,14 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 61C3251B1179A300001E70B1 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 61C3255B1179A384001E70B1 /* OpenAL.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; /* End PBXFrameworksBuildPhase section */ /* Begin PBXGroup section */ @@ -358,6 +398,7 @@ children = ( 1D6058910D05DD3D006BFB54 /* HedgewarsMobile.app */, 928301170F10CAFC00CC5A3C /* libfpc.a */, + 61C3251D1179A300001E70B1 /* libopenalbridge.a */, ); name = Products; sourceTree = ""; @@ -379,6 +420,7 @@ 29B97315FDCFA39411CA2CEA /* Other Sources */ = { isa = PBXGroup; children = ( + 61C325371179A325001E70B1 /* openalbridge */, 6184DEA111795DBD00AF6EFA /* UIImageExtra.h */, 6184DEA211795DBD00AF6EFA /* UIImageExtra.m */, 61798857114AA48A00BA94A9 /* CGPointUtils.h */, @@ -424,6 +466,7 @@ 28FD14FF0DC6FC520079059D /* OpenGLES.framework */, 28FD15070DC6FC5B0079059D /* QuartzCore.framework */, 1DF5F4DF0D08C38300B7A737 /* UIKit.framework */, + 61C3255A1179A384001E70B1 /* OpenAL.framework */, 61798916114AAF2100BA94A9 /* libfreetype_arm.a */, 61798917114AAF2100BA94A9 /* libfreetype_x86.a */, 61798918114AAF2100BA94A9 /* libpng_arm.a */, @@ -619,6 +662,22 @@ name = "second level"; sourceTree = ""; }; + 61C325371179A325001E70B1 /* openalbridge */ = { + isa = PBXGroup; + children = ( + 61C325391179A336001E70B1 /* errlib.c */, + 61C3253A1179A336001E70B1 /* errlib.h */, + 61C3253B1179A336001E70B1 /* globals.h */, + 61C3253C1179A336001E70B1 /* loaders.c */, + 61C3253D1179A336001E70B1 /* loaders.h */, + 61C3253E1179A336001E70B1 /* openalbridge.c */, + 61C325401179A336001E70B1 /* openalbridge.h */, + 61C325411179A336001E70B1 /* wrappers.c */, + 61C325421179A336001E70B1 /* wrappers.h */, + ); + name = openalbridge; + sourceTree = ""; + }; 61CE2509115E74260098C467 /* XIB */ = { isa = PBXGroup; children = ( @@ -671,6 +730,21 @@ }; /* End PBXGroup section */ +/* Begin PBXHeadersBuildPhase section */ + 61C325191179A300001E70B1 /* Headers */ = { + isa = PBXHeadersBuildPhase; + buildActionMask = 2147483647; + files = ( + 61C325441179A336001E70B1 /* errlib.h in Headers */, + 61C325451179A336001E70B1 /* globals.h in Headers */, + 61C325471179A336001E70B1 /* loaders.h in Headers */, + 61C325491179A336001E70B1 /* openalbridge.h in Headers */, + 61C3254B1179A336001E70B1 /* wrappers.h in Headers */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXHeadersBuildPhase section */ + /* Begin PBXNativeTarget section */ 1D6058900D05DD3D006BFB54 /* HedgewarsMobile */ = { isa = PBXNativeTarget; @@ -685,6 +759,7 @@ 9283015B0F10E46D00CC5A3C /* PBXBuildRule */, ); dependencies = ( + 61C325211179A30E001E70B1 /* PBXTargetDependency */, 9283015A0F10E41300CC5A3C /* PBXTargetDependency */, ); name = HedgewarsMobile; @@ -692,6 +767,23 @@ productReference = 1D6058910D05DD3D006BFB54 /* HedgewarsMobile.app */; productType = "com.apple.product-type.application"; }; + 61C3251C1179A300001E70B1 /* openalbridge */ = { + isa = PBXNativeTarget; + buildConfigurationList = 61C325351179A314001E70B1 /* Build configuration list for PBXNativeTarget "openalbridge" */; + buildPhases = ( + 61C325191179A300001E70B1 /* Headers */, + 61C3251A1179A300001E70B1 /* Sources */, + 61C3251B1179A300001E70B1 /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = openalbridge; + productName = openalbridge; + productReference = 61C3251D1179A300001E70B1 /* libopenalbridge.a */; + productType = "com.apple.product-type.library.static"; + }; 928301160F10CAFC00CC5A3C /* fpc */ = { isa = PBXNativeTarget; buildConfigurationList = 9283011C0F10CB4B00CC5A3C /* Build configuration list for PBXNativeTarget "fpc" */; @@ -744,6 +836,7 @@ 1D6058900D05DD3D006BFB54 /* HedgewarsMobile */, 928301160F10CAFC00CC5A3C /* fpc */, 6179928B114AE0C800BA94A9 /* UpdateDataFolder */, + 61C3251C1179A300001E70B1 /* openalbridge */, ); }; /* End PBXProject section */ @@ -945,9 +1038,25 @@ ); runOnlyForDeploymentPostprocessing = 0; }; + 61C3251A1179A300001E70B1 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 61C325431179A336001E70B1 /* errlib.c in Sources */, + 61C325461179A336001E70B1 /* loaders.c in Sources */, + 61C325481179A336001E70B1 /* openalbridge.c in Sources */, + 61C3254A1179A336001E70B1 /* wrappers.c in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; /* End PBXSourcesBuildPhase section */ /* Begin PBXTargetDependency section */ + 61C325211179A30E001E70B1 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 61C3251C1179A300001E70B1 /* openalbridge */; + targetProxy = 61C325201179A30E001E70B1 /* PBXContainerItemProxy */; + }; 9283015A0F10E41300CC5A3C /* PBXTargetDependency */ = { isa = PBXTargetDependency; target = 928301160F10CAFC00CC5A3C /* fpc */; @@ -1013,6 +1122,53 @@ }; name = Release; }; + 61C3251E1179A300001E70B1 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = NO; + GCC_DYNAMIC_NO_PIC = NO; + GCC_OPTIMIZATION_LEVEL = 0; + HEADER_SEARCH_PATHS = ( + /Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator3.2.sdk/System/Library/Frameworks/OpenAL.framework/Headers, + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/include\"/**", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/src\"/**", + "\"$(SRCROOT)/../../../Library/lpng141\"", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL_net\"", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL_mixer\"", + "\"$(SRCROOT)/../../../Library/libvorbis-1.3.1/include\"", + "\"$(SRCROOT)/../../../Library/libogg-1.2.0/include\"", + ); + OTHER_LDFLAGS = ""; + PREBINDING = NO; + PRODUCT_NAME = openalbridge; + }; + name = Debug; + }; + 61C3251F1179A300001E70B1 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + COPY_PHASE_STRIP = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + GCC_ENABLE_FIX_AND_CONTINUE = NO; + HEADER_SEARCH_PATHS = ( + /Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator3.2.sdk/System/Library/Frameworks/OpenAL.framework/Headers, + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/include\"/**", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/src\"/**", + "\"$(SRCROOT)/../../../Library/lpng141\"", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL_net\"", + "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL_mixer\"", + "\"$(SRCROOT)/../../../Library/libvorbis-1.3.1/include\"", + "\"$(SRCROOT)/../../../Library/libogg-1.2.0/include\"", + ); + OTHER_LDFLAGS = ""; + PREBINDING = NO; + PRODUCT_NAME = openalbridge; + ZERO_LINK = NO; + }; + name = Release; + }; 928301180F10CAFD00CC5A3C /* Debug */ = { isa = XCBuildConfiguration; buildSettings = { @@ -1058,6 +1214,7 @@ GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; HEADER_SEARCH_PATHS = ( + /Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator3.2.sdk/System/Library/Frameworks/OpenAL.framework/Headers, "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/include\"/**", "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/src\"/**", "\"$(SRCROOT)/../../../Library/lpng141\"", @@ -1095,6 +1252,7 @@ GCC_WARN_ABOUT_RETURN_TYPE = YES; GCC_WARN_UNUSED_VARIABLE = YES; HEADER_SEARCH_PATHS = ( + /Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator3.2.sdk/System/Library/Frameworks/OpenAL.framework/Headers, "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/include\"/**", "\"$(SRCROOT)/../../../Library/SDL-1.3/SDL/src\"/**", "\"$(SRCROOT)/../../../Library/lpng141\"", @@ -1134,6 +1292,15 @@ defaultConfigurationIsVisible = 0; defaultConfigurationName = Release; }; + 61C325351179A314001E70B1 /* Build configuration list for PBXNativeTarget "openalbridge" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 61C3251E1179A300001E70B1 /* Debug */, + 61C3251F1179A300001E70B1 /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; 9283011C0F10CB4B00CC5A3C /* Build configuration list for PBXNativeTarget "fpc" */ = { isa = XCConfigurationList; buildConfigurations = ( diff -r ac5d14a35482 -r a767dd3786b5 project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.mode1v3 --- a/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.mode1v3 Sat Apr 17 04:59:10 2010 +0000 +++ b/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.mode1v3 Sat Apr 17 08:30:34 2010 +0000 @@ -197,7 +197,49 @@ Notifications OpenEditors - + + + Content + + PBXProjectModuleGUID + 61C325971179A75D001E70B1 + PBXProjectModuleLabel + VoicesViewController.m + PBXSplitModuleInNavigatorKey + + Split0 + + PBXProjectModuleGUID + 61C325981179A75D001E70B1 + PBXProjectModuleLabel + VoicesViewController.m + _historyCapacity + 0 + bookmark + 61C326081179AEE0001E70B1 + history + + 61C325D51179A93D001E70B1 + 61C325D61179A93D001E70B1 + + + SplitCount + 1 + + StatusBarVisibility + + + Geometry + + Frame + {{0, 20}, {1002, 681}} + PBXModuleWindowStatusBarHidden2 + + RubberWindowFrame + 493 283 1002 722 0 0 1920 1178 + + + PerspectiveWidths -1 @@ -229,8 +271,6 @@ Layout - BecomeActive - ContentConfiguration PBXBottomSmartGroupGIDs @@ -254,7 +294,7 @@ PBXSmartGroupTreeModuleColumnWidthsKey - 244 + 248 PBXSmartGroupTreeModuleColumnsKey_v4 @@ -272,26 +312,22 @@ 611B0A94116B621600112153 61A11AD01168DB1F00359010 618BE596117512A300F22556 - 29B97315FDCFA39411CA2CEA 29B97317FDCFA39411CA2CEA + 19C28FACFE9D520D11CA2CBB 1C37FBAC04509CD000000102 - 6184DF76117973AF00AF6EFA + 61C325931179A75D001E70B1 1C37FAAC04509CD000000102 1C37FABC05509CD000000102 PBXSmartGroupTreeModuleOutlineStateSelectionKey - 31 - 20 - 5 - 4 - 2 + 41 0 PBXSmartGroupTreeModuleOutlineStateVisibleRectKey - {{0, 221}, {244, 558}} + {{0, 424}, {248, 558}} PBXTopSmartGroupGIDs @@ -303,19 +339,19 @@ GeometryConfiguration Frame - {{0, 0}, {261, 576}} + {{0, 0}, {265, 576}} GroupTreeTableConfiguration MainColumn - 244 + 248 RubberWindowFrame - 685 523 801 617 0 0 1920 1178 + 301 523 801 617 0 0 1920 1178 Module PBXSmartGroupTreeModule Proportion - 261pt + 265pt Dock @@ -326,7 +362,7 @@ PBXProjectModuleGUID 1CE0B20306471E060097A5F4 PBXProjectModuleLabel - UIImageExtra.m + openalbridge.c PBXSplitModuleInNavigatorKey Split0 @@ -334,11 +370,11 @@ PBXProjectModuleGUID 1CE0B20406471E060097A5F4 PBXProjectModuleLabel - UIImageExtra.m + openalbridge.c _historyCapacity 0 bookmark - 6184DFF81179809B00AF6EFA + 61C326071179AEE0001E70B1 history 6179889D114AA5BD00BA94A9 @@ -537,7 +573,11 @@ 6184DF4511796A9200AF6EFA 6184DF9A1179752300AF6EFA 6184DFE111797D2500AF6EFA - 6184DFE211797D2500AF6EFA + 61C325231179A314001E70B1 + 61C325681179A3A0001E70B1 + 61C325691179A3A0001E70B1 + 61C325DD1179A993001E70B1 + 61C325DE1179A993001E70B1 SplitCount @@ -549,16 +589,18 @@ GeometryConfiguration Frame - {{0, 0}, {535, 246}} + {{0, 0}, {531, 234}} RubberWindowFrame - 685 523 801 617 0 0 1920 1178 + 301 523 801 617 0 0 1920 1178 Module PBXNavigatorGroup Proportion - 246pt + 234pt + BecomeActive + ContentConfiguration PBXProjectModuleGUID @@ -569,18 +611,18 @@ GeometryConfiguration Frame - {{0, 251}, {535, 325}} + {{0, 239}, {531, 337}} RubberWindowFrame - 685 523 801 617 0 0 1920 1178 + 301 523 801 617 0 0 1920 1178 Module XCDetailModule Proportion - 325pt + 337pt Proportion - 535pt + 531pt Name @@ -595,9 +637,9 @@ TableOfContents - 6184DE121178F46B00AF6EFA + 61C325261179A314001E70B1 1CE0B1FE06471DED0097A5F4 - 6184DE131178F46B00AF6EFA + 61C325271179A314001E70B1 1CE0B20306471E060097A5F4 1CE0B20506471E060097A5F4 @@ -735,16 +777,17 @@ 5 WindowOrderList - 6184DE581178F75B00AF6EFA - 6184DE371178F56B00AF6EFA - 6184DE2F1178F4BD00AF6EFA - 1C78EAAD065D492600B07095 + 61C326091179AEE0001E70B1 + 61C325D91179A93D001E70B1 + 61C325CE1179A8F9001E70B1 1CD10A99069EF8BA00B06720 61798848114AA42600BA94A9 /Users/vittorio/hedgewars/trunk/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj + 61C325971179A75D001E70B1 + 1C78EAAD065D492600B07095 WindowString - 685 523 801 617 0 0 1920 1178 + 301 523 801 617 0 0 1920 1178 WindowToolsV3 @@ -760,14 +803,12 @@ Dock - BecomeActive - ContentConfiguration PBXProjectModuleGUID 1CD0528F0623707200166675 PBXProjectModuleLabel - FortsViewController.m + openalbridge.c StatusBarVisibility @@ -784,6 +825,8 @@ 307pt + BecomeActive + ContentConfiguration PBXProjectModuleGUID @@ -823,7 +866,7 @@ TableOfContents 61798848114AA42600BA94A9 - 6184DE141178F46B00AF6EFA + 61C325281179A314001E70B1 1CD0528F0623707200166675 XCMainBuildResultsModuleGUID @@ -947,13 +990,13 @@ TableOfContents 1CD10A99069EF8BA00B06720 - 6184DE271178F4BD00AF6EFA + 61C325291179A314001E70B1 1C162984064C10D400B95A72 - 6184DE281178F4BD00AF6EFA - 6184DE291178F4BD00AF6EFA - 6184DE2A1178F4BD00AF6EFA - 6184DE2B1178F4BD00AF6EFA - 6184DE2C1178F4BD00AF6EFA + 61C3252A1179A314001E70B1 + 61C3252B1179A314001E70B1 + 61C3252C1179A314001E70B1 + 61C3252D1179A314001E70B1 + 61C3252E1179A314001E70B1 ToolbarConfiguration xcode.toolbar.config.debugV3 @@ -1117,7 +1160,7 @@ TableOfContents 1C78EAAD065D492600B07095 - 6184DE2D1178F4BD00AF6EFA + 61C325CC1179A8F9001E70B1 1C78EAAC065D492600B07095 ToolbarConfiguration @@ -1127,7 +1170,7 @@ WindowToolGUID 1C78EAAD065D492600B07095 WindowToolIsVisible - + Identifier diff -r ac5d14a35482 -r a767dd3786b5 project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.pbxuser --- a/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.pbxuser Sat Apr 17 04:59:10 2010 +0000 +++ b/project_files/HedgewarsMobile/HedgewarsMobile.xcodeproj/vittorio.pbxuser Sat Apr 17 08:30:34 2010 +0000 @@ -12,7 +12,7 @@ activeSDKPreference = iphonesimulator3.2; activeTarget = 1D6058900D05DD3D006BFB54 /* HedgewarsMobile */; addToTargets = ( - 1D6058900D05DD3D006BFB54 /* HedgewarsMobile */, + 61C3251C1179A300001E70B1 /* openalbridge */, ); breakpoints = ( ); @@ -68,7 +68,7 @@ PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; PBXFileTableDataSourceColumnWidthsKey = ( 20, - 296, + 292, 20, 48, 43, @@ -90,7 +90,7 @@ PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID; PBXFileTableDataSourceColumnWidthsKey = ( 20, - 256, + 252, 60, 20, 48, @@ -107,8 +107,8 @@ PBXFileDataSource_Warnings_ColumnID, ); }; - PBXPerProjectTemplateStateSaveDate = 293139562; - PBXWorkspaceStateSaveDate = 293139562; + PBXPerProjectTemplateStateSaveDate = 293184239; + PBXWorkspaceStateSaveDate = 293184239; }; perUserProjectItems = { 61056377116C0393003C420C = 61056377116C0393003C420C /* PBXBookmark */; @@ -155,233 +155,233 @@ 617B27B91171617A004A76A2 = 617B27B91171617A004A76A2 /* PBXTextBookmark */; 617B280E117164FC004A76A2 = 617B280E117164FC004A76A2 /* PBXTextBookmark */; 617E1DB5116FEE5B002EF3D8 = 617E1DB5116FEE5B002EF3D8 /* PBXTextBookmark */; - 6184DE111178F46B00AF6EFA /* PBXTextBookmark */ = 6184DE111178F46B00AF6EFA /* PBXTextBookmark */; - 6184DE1D1178F4B900AF6EFA /* PBXTextBookmark */ = 6184DE1D1178F4B900AF6EFA /* PBXTextBookmark */; - 6184DE201178F4BD00AF6EFA /* PBXTextBookmark */ = 6184DE201178F4BD00AF6EFA /* PBXTextBookmark */; - 6184DE211178F4BD00AF6EFA /* PBXTextBookmark */ = 6184DE211178F4BD00AF6EFA /* PBXTextBookmark */; - 6184DE221178F4BD00AF6EFA /* PBXTextBookmark */ = 6184DE221178F4BD00AF6EFA /* PBXTextBookmark */; - 6184DE251178F4BD00AF6EFA /* PBXTextBookmark */ = 6184DE251178F4BD00AF6EFA /* PBXTextBookmark */; - 6184DE261178F4BD00AF6EFA /* PBXTextBookmark */ = 6184DE261178F4BD00AF6EFA /* PBXTextBookmark */; - 6184DE341178F56B00AF6EFA /* PBXTextBookmark */ = 6184DE341178F56B00AF6EFA /* PBXTextBookmark */; - 6184DE351178F56B00AF6EFA /* PBXTextBookmark */ = 6184DE351178F56B00AF6EFA /* PBXTextBookmark */; - 6184DE3B1178F5BA00AF6EFA /* PBXTextBookmark */ = 6184DE3B1178F5BA00AF6EFA /* PBXTextBookmark */; - 6184DE3C1178F5BA00AF6EFA /* PBXTextBookmark */ = 6184DE3C1178F5BA00AF6EFA /* PBXTextBookmark */; - 6184DE401178F5C400AF6EFA /* PBXTextBookmark */ = 6184DE401178F5C400AF6EFA /* PBXTextBookmark */; - 6184DE411178F5C400AF6EFA /* PBXTextBookmark */ = 6184DE411178F5C400AF6EFA /* PBXTextBookmark */; - 6184DE471178F68C00AF6EFA /* PBXTextBookmark */ = 6184DE471178F68C00AF6EFA /* PBXTextBookmark */; - 6184DE481178F68C00AF6EFA /* PBXTextBookmark */ = 6184DE481178F68C00AF6EFA /* PBXTextBookmark */; - 6184DE4D1178F6F200AF6EFA /* PBXTextBookmark */ = 6184DE4D1178F6F200AF6EFA /* PBXTextBookmark */; - 6184DE4E1178F6F200AF6EFA /* PBXTextBookmark */ = 6184DE4E1178F6F200AF6EFA /* PBXTextBookmark */; - 6184DE521178F72200AF6EFA /* PBXTextBookmark */ = 6184DE521178F72200AF6EFA /* PBXTextBookmark */; - 6184DE531178F72200AF6EFA /* PBXTextBookmark */ = 6184DE531178F72200AF6EFA /* PBXTextBookmark */; - 6184DE5A1178F75E00AF6EFA /* PBXTextBookmark */ = 6184DE5A1178F75E00AF6EFA /* PBXTextBookmark */; - 6184DE5B1178F75E00AF6EFA /* PBXTextBookmark */ = 6184DE5B1178F75E00AF6EFA /* PBXTextBookmark */; - 6184DE5E1178F7D700AF6EFA /* PBXTextBookmark */ = 6184DE5E1178F7D700AF6EFA /* PBXTextBookmark */; - 6184DE5F1178F7D700AF6EFA /* PBXTextBookmark */ = 6184DE5F1178F7D700AF6EFA /* PBXTextBookmark */; - 6184DE631178F80E00AF6EFA /* PBXTextBookmark */ = 6184DE631178F80E00AF6EFA /* PBXTextBookmark */; - 6184DE641178F80E00AF6EFA /* PBXTextBookmark */ = 6184DE641178F80E00AF6EFA /* PBXTextBookmark */; - 6184DE681178F84100AF6EFA /* PBXTextBookmark */ = 6184DE681178F84100AF6EFA /* PBXTextBookmark */; - 6184DE691178F84100AF6EFA /* PBXTextBookmark */ = 6184DE691178F84100AF6EFA /* PBXTextBookmark */; - 6184DE6F117901F600AF6EFA /* PBXBookmark */ = 6184DE6F117901F600AF6EFA /* PBXBookmark */; - 6184DE7511795AEE00AF6EFA /* PBXBookmark */ = 6184DE7511795AEE00AF6EFA /* PBXBookmark */; - 6184DE7E11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE7E11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE7F11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE7F11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8011795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8011795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8111795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8111795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8211795D3F00AF6EFA /* PBXBookmark */ = 6184DE8211795D3F00AF6EFA /* PBXBookmark */; - 6184DE8311795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8311795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8611795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8611795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8911795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8911795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8A11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8A11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8B11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8B11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8E11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8E11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE8F11795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE8F11795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE9011795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE9011795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE9311795D3F00AF6EFA /* PBXTextBookmark */ = 6184DE9311795D3F00AF6EFA /* PBXTextBookmark */; - 6184DE9511795D6700AF6EFA /* PBXTextBookmark */ = 6184DE9511795D6700AF6EFA /* PBXTextBookmark */; - 6184DE9611795D6700AF6EFA /* PBXTextBookmark */ = 6184DE9611795D6700AF6EFA /* PBXTextBookmark */; - 6184DE9711795D6700AF6EFA /* PBXTextBookmark */ = 6184DE9711795D6700AF6EFA /* PBXTextBookmark */; - 6184DE9811795D6700AF6EFA /* PBXTextBookmark */ = 6184DE9811795D6700AF6EFA /* PBXTextBookmark */; - 6184DE9911795D6700AF6EFA /* PBXTextBookmark */ = 6184DE9911795D6700AF6EFA /* PBXTextBookmark */; - 6184DE9C11795DA500AF6EFA /* PBXTextBookmark */ = 6184DE9C11795DA500AF6EFA /* PBXTextBookmark */; - 6184DE9D11795DA500AF6EFA /* PBXTextBookmark */ = 6184DE9D11795DA500AF6EFA /* PBXTextBookmark */; - 6184DE9E11795DA500AF6EFA /* PBXTextBookmark */ = 6184DE9E11795DA500AF6EFA /* PBXTextBookmark */; - 6184DE9F11795DA500AF6EFA /* PBXTextBookmark */ = 6184DE9F11795DA500AF6EFA /* PBXTextBookmark */; - 6184DEA011795DA500AF6EFA /* PBXTextBookmark */ = 6184DEA011795DA500AF6EFA /* PBXTextBookmark */; - 6184DEAF11795FC700AF6EFA /* PBXTextBookmark */ = 6184DEAF11795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB011795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB011795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB111795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB111795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB211795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB211795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB311795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB311795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB611795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB611795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB711795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB711795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB811795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB811795FC700AF6EFA /* PBXTextBookmark */; - 6184DEB911795FC700AF6EFA /* PBXTextBookmark */ = 6184DEB911795FC700AF6EFA /* PBXTextBookmark */; - 6184DEBA11795FC700AF6EFA /* PBXTextBookmark */ = 6184DEBA11795FC700AF6EFA /* PBXTextBookmark */; - 6184DEBF1179604200AF6EFA /* PBXTextBookmark */ = 6184DEBF1179604200AF6EFA /* PBXTextBookmark */; - 6184DEC01179604200AF6EFA /* PBXTextBookmark */ = 6184DEC01179604200AF6EFA /* PBXTextBookmark */; - 6184DEC11179604200AF6EFA /* PBXTextBookmark */ = 6184DEC11179604200AF6EFA /* PBXTextBookmark */; - 6184DEC21179604200AF6EFA /* PBXTextBookmark */ = 6184DEC21179604200AF6EFA /* PBXTextBookmark */; - 6184DEC31179604200AF6EFA /* PBXTextBookmark */ = 6184DEC31179604200AF6EFA /* PBXTextBookmark */; - 6184DECB1179609000AF6EFA /* PBXTextBookmark */ = 6184DECB1179609000AF6EFA /* PBXTextBookmark */; - 6184DECC1179609000AF6EFA /* PBXTextBookmark */ = 6184DECC1179609000AF6EFA /* PBXTextBookmark */; - 6184DECD1179609000AF6EFA /* PBXTextBookmark */ = 6184DECD1179609000AF6EFA /* PBXTextBookmark */; - 6184DECE1179609000AF6EFA /* PBXTextBookmark */ = 6184DECE1179609000AF6EFA /* PBXTextBookmark */; - 6184DECF1179609000AF6EFA /* PBXTextBookmark */ = 6184DECF1179609000AF6EFA /* PBXTextBookmark */; - 6184DED71179629900AF6EFA /* PBXTextBookmark */ = 6184DED71179629900AF6EFA /* PBXTextBookmark */; - 6184DED81179629900AF6EFA /* PBXTextBookmark */ = 6184DED81179629900AF6EFA /* PBXTextBookmark */; - 6184DED91179629900AF6EFA /* PBXTextBookmark */ = 6184DED91179629900AF6EFA /* PBXTextBookmark */; - 6184DEDA1179629900AF6EFA /* PBXTextBookmark */ = 6184DEDA1179629900AF6EFA /* PBXTextBookmark */; - 6184DEDB1179629900AF6EFA /* PBXTextBookmark */ = 6184DEDB1179629900AF6EFA /* PBXTextBookmark */; - 6184DEDC1179629900AF6EFA /* PBXTextBookmark */ = 6184DEDC1179629900AF6EFA /* PBXTextBookmark */; - 6184DEDD1179629900AF6EFA /* PBXTextBookmark */ = 6184DEDD1179629900AF6EFA /* PBXTextBookmark */; - 6184DEE11179634500AF6EFA /* PBXTextBookmark */ = 6184DEE11179634500AF6EFA /* PBXTextBookmark */; - 6184DEE21179634500AF6EFA /* PBXTextBookmark */ = 6184DEE21179634500AF6EFA /* PBXTextBookmark */; - 6184DEE31179634500AF6EFA /* PBXTextBookmark */ = 6184DEE31179634500AF6EFA /* PBXTextBookmark */; - 6184DEE41179634500AF6EFA /* PBXTextBookmark */ = 6184DEE41179634500AF6EFA /* PBXTextBookmark */; - 6184DEE51179634500AF6EFA /* PBXTextBookmark */ = 6184DEE51179634500AF6EFA /* PBXTextBookmark */; - 6184DEE91179637C00AF6EFA /* PBXTextBookmark */ = 6184DEE91179637C00AF6EFA /* PBXTextBookmark */; - 6184DEEA1179637C00AF6EFA /* PBXTextBookmark */ = 6184DEEA1179637C00AF6EFA /* PBXTextBookmark */; - 6184DEEB1179637C00AF6EFA /* PBXTextBookmark */ = 6184DEEB1179637C00AF6EFA /* PBXTextBookmark */; - 6184DEEC1179637C00AF6EFA /* PBXTextBookmark */ = 6184DEEC1179637C00AF6EFA /* PBXTextBookmark */; - 6184DEED1179637C00AF6EFA /* PBXTextBookmark */ = 6184DEED1179637C00AF6EFA /* PBXTextBookmark */; - 6184DEEF1179639700AF6EFA /* PBXTextBookmark */ = 6184DEEF1179639700AF6EFA /* PBXTextBookmark */; - 6184DEF01179639700AF6EFA /* PBXTextBookmark */ = 6184DEF01179639700AF6EFA /* PBXTextBookmark */; - 6184DEF11179639700AF6EFA /* PBXTextBookmark */ = 6184DEF11179639700AF6EFA /* PBXTextBookmark */; - 6184DEF21179639700AF6EFA /* PBXTextBookmark */ = 6184DEF21179639700AF6EFA /* PBXTextBookmark */; - 6184DEF31179639700AF6EFA /* PBXTextBookmark */ = 6184DEF31179639700AF6EFA /* PBXTextBookmark */; - 6184DEF61179659200AF6EFA /* PBXTextBookmark */ = 6184DEF61179659200AF6EFA /* PBXTextBookmark */; - 6184DEF71179659200AF6EFA /* PBXTextBookmark */ = 6184DEF71179659200AF6EFA /* PBXTextBookmark */; - 6184DEF81179659200AF6EFA /* PBXTextBookmark */ = 6184DEF81179659200AF6EFA /* PBXTextBookmark */; - 6184DEF91179659200AF6EFA /* PBXTextBookmark */ = 6184DEF91179659200AF6EFA /* PBXTextBookmark */; - 6184DEFA1179659200AF6EFA /* PBXTextBookmark */ = 6184DEFA1179659200AF6EFA /* PBXTextBookmark */; - 6184DEFB1179659200AF6EFA /* PBXTextBookmark */ = 6184DEFB1179659200AF6EFA /* PBXTextBookmark */; - 6184DEFC1179659200AF6EFA /* PBXTextBookmark */ = 6184DEFC1179659200AF6EFA /* PBXTextBookmark */; - 6184DF001179666500AF6EFA /* PBXTextBookmark */ = 6184DF001179666500AF6EFA /* PBXTextBookmark */; - 6184DF011179666500AF6EFA /* PBXTextBookmark */ = 6184DF011179666500AF6EFA /* PBXTextBookmark */; - 6184DF021179666500AF6EFA /* PBXTextBookmark */ = 6184DF021179666500AF6EFA /* PBXTextBookmark */; - 6184DF031179666500AF6EFA /* PBXTextBookmark */ = 6184DF031179666500AF6EFA /* PBXTextBookmark */; - 6184DF041179666500AF6EFA /* PBXTextBookmark */ = 6184DF041179666500AF6EFA /* PBXTextBookmark */; - 6184DF06117966F400AF6EFA /* PBXTextBookmark */ = 6184DF06117966F400AF6EFA /* PBXTextBookmark */; - 6184DF07117966F400AF6EFA /* PBXTextBookmark */ = 6184DF07117966F400AF6EFA /* PBXTextBookmark */; - 6184DF08117966F400AF6EFA /* PBXTextBookmark */ = 6184DF08117966F400AF6EFA /* PBXTextBookmark */; - 6184DF09117966F700AF6EFA /* PBXBookmark */ = 6184DF09117966F700AF6EFA /* PBXBookmark */; - 6184DF10117967DC00AF6EFA /* PBXTextBookmark */ = 6184DF10117967DC00AF6EFA /* PBXTextBookmark */; - 6184DF11117967DC00AF6EFA /* PBXTextBookmark */ = 6184DF11117967DC00AF6EFA /* PBXTextBookmark */; - 6184DF14117967DC00AF6EFA /* PBXTextBookmark */ = 6184DF14117967DC00AF6EFA /* PBXTextBookmark */; - 6184DF15117967DC00AF6EFA /* PBXTextBookmark */ = 6184DF15117967DC00AF6EFA /* PBXTextBookmark */; - 6184DF191179680800AF6EFA /* PBXTextBookmark */ = 6184DF191179680800AF6EFA /* PBXTextBookmark */; - 6184DF1A1179680800AF6EFA /* PBXTextBookmark */ = 6184DF1A1179680800AF6EFA /* PBXTextBookmark */; - 6184DF1B1179680800AF6EFA /* PBXTextBookmark */ = 6184DF1B1179680800AF6EFA /* PBXTextBookmark */; - 6184DF1D1179688500AF6EFA /* PBXBookmark */ = 6184DF1D1179688500AF6EFA /* PBXBookmark */; - 6184DF1E117968A500AF6EFA /* PBXBookmark */ = 6184DF1E117968A500AF6EFA /* PBXBookmark */; - 6184DF231179691200AF6EFA /* PBXTextBookmark */ = 6184DF231179691200AF6EFA /* PBXTextBookmark */; - 6184DF261179691200AF6EFA /* PBXTextBookmark */ = 6184DF261179691200AF6EFA /* PBXTextBookmark */; - 6184DF271179691200AF6EFA /* PBXTextBookmark */ = 6184DF271179691200AF6EFA /* PBXTextBookmark */; - 6184DF2A1179691200AF6EFA /* PBXTextBookmark */ = 6184DF2A1179691200AF6EFA /* PBXTextBookmark */; - 6184DF2C1179691D00AF6EFA /* PBXTextBookmark */ = 6184DF2C1179691D00AF6EFA /* PBXTextBookmark */; - 6184DF2D1179691D00AF6EFA /* PBXTextBookmark */ = 6184DF2D1179691D00AF6EFA /* PBXTextBookmark */; - 6184DF2E1179691D00AF6EFA /* PBXTextBookmark */ = 6184DF2E1179691D00AF6EFA /* PBXTextBookmark */; - 6184DF2F1179691D00AF6EFA /* PBXTextBookmark */ = 6184DF2F1179691D00AF6EFA /* PBXTextBookmark */; - 6184DF34117969EF00AF6EFA /* PBXTextBookmark */ = 6184DF34117969EF00AF6EFA /* PBXTextBookmark */; - 6184DF35117969EF00AF6EFA /* PBXTextBookmark */ = 6184DF35117969EF00AF6EFA /* PBXTextBookmark */; - 6184DF36117969EF00AF6EFA /* PBXTextBookmark */ = 6184DF36117969EF00AF6EFA /* PBXTextBookmark */; - 6184DF37117969EF00AF6EFA /* PBXTextBookmark */ = 6184DF37117969EF00AF6EFA /* PBXTextBookmark */; - 6184DF3B117969FF00AF6EFA /* PBXTextBookmark */ = 6184DF3B117969FF00AF6EFA /* PBXTextBookmark */; - 6184DF3C117969FF00AF6EFA /* PBXTextBookmark */ = 6184DF3C117969FF00AF6EFA /* PBXTextBookmark */; - 6184DF3D117969FF00AF6EFA /* PBXTextBookmark */ = 6184DF3D117969FF00AF6EFA /* PBXTextBookmark */; - 6184DF3E117969FF00AF6EFA /* PBXTextBookmark */ = 6184DF3E117969FF00AF6EFA /* PBXTextBookmark */; - 6184DF4011796A3200AF6EFA /* PBXBookmark */ = 6184DF4011796A3200AF6EFA /* PBXBookmark */; - 6184DF4111796A6400AF6EFA /* PBXBookmark */ = 6184DF4111796A6400AF6EFA /* PBXBookmark */; - 6184DF4411796A9200AF6EFA /* PBXTextBookmark */ = 6184DF4411796A9200AF6EFA /* PBXTextBookmark */; - 6184DF4511796A9200AF6EFA /* PBXTextBookmark */ = 6184DF4511796A9200AF6EFA /* PBXTextBookmark */; - 6184DF4611796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4611796A9300AF6EFA /* PBXTextBookmark */; - 6184DF4911796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4911796A9300AF6EFA /* PBXTextBookmark */; - 6184DF4C11796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4C11796A9300AF6EFA /* PBXTextBookmark */; - 6184DF4D11796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4D11796A9300AF6EFA /* PBXTextBookmark */; - 6184DF4E11796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4E11796A9300AF6EFA /* PBXTextBookmark */; - 6184DF4F11796A9300AF6EFA /* PBXTextBookmark */ = 6184DF4F11796A9300AF6EFA /* PBXTextBookmark */; - 6184DF6F117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF6F117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF70117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF70117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF71117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF71117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF72117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF72117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF73117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF73117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF74117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF74117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF75117972FE00AF6EFA /* PBXTextBookmark */ = 6184DF75117972FE00AF6EFA /* PBXTextBookmark */; - 6184DF77117973AF00AF6EFA /* PBXTextBookmark */ = 6184DF77117973AF00AF6EFA /* PBXTextBookmark */; - 6184DF78117973AF00AF6EFA /* PBXTextBookmark */ = 6184DF78117973AF00AF6EFA /* PBXTextBookmark */; - 6184DF79117973AF00AF6EFA /* PBXTextBookmark */ = 6184DF79117973AF00AF6EFA /* PBXTextBookmark */; - 6184DF7A117973AF00AF6EFA /* PBXTextBookmark */ = 6184DF7A117973AF00AF6EFA /* PBXTextBookmark */; - 6184DF7B117973AF00AF6EFA /* PBXTextBookmark */ = 6184DF7B117973AF00AF6EFA /* PBXTextBookmark */; - 6184DF7C117973BF00AF6EFA /* PBXTextBookmark */ = 6184DF7C117973BF00AF6EFA /* PBXTextBookmark */; - 6184DF7D117973BF00AF6EFA /* PBXTextBookmark */ = 6184DF7D117973BF00AF6EFA /* PBXTextBookmark */; - 6184DF7E117973BF00AF6EFA /* PBXTextBookmark */ = 6184DF7E117973BF00AF6EFA /* PBXTextBookmark */; - 6184DF7F117973BF00AF6EFA /* PBXTextBookmark */ = 6184DF7F117973BF00AF6EFA /* PBXTextBookmark */; - 6184DF80117973BF00AF6EFA /* PBXTextBookmark */ = 6184DF80117973BF00AF6EFA /* PBXTextBookmark */; - 6184DF81117973CC00AF6EFA /* PBXTextBookmark */ = 6184DF81117973CC00AF6EFA /* PBXTextBookmark */; - 6184DF82117973CC00AF6EFA /* PBXTextBookmark */ = 6184DF82117973CC00AF6EFA /* PBXTextBookmark */; - 6184DF83117973CC00AF6EFA /* PBXTextBookmark */ = 6184DF83117973CC00AF6EFA /* PBXTextBookmark */; - 6184DF84117973CC00AF6EFA /* PBXTextBookmark */ = 6184DF84117973CC00AF6EFA /* PBXTextBookmark */; - 6184DF85117973CC00AF6EFA /* PBXTextBookmark */ = 6184DF85117973CC00AF6EFA /* PBXTextBookmark */; - 6184DF86117973D500AF6EFA /* PBXTextBookmark */ = 6184DF86117973D500AF6EFA /* PBXTextBookmark */; - 6184DF87117973D500AF6EFA /* PBXTextBookmark */ = 6184DF87117973D500AF6EFA /* PBXTextBookmark */; - 6184DF88117973D500AF6EFA /* PBXTextBookmark */ = 6184DF88117973D500AF6EFA /* PBXTextBookmark */; - 6184DF89117973D500AF6EFA /* PBXTextBookmark */ = 6184DF89117973D500AF6EFA /* PBXTextBookmark */; - 6184DF8A117973D500AF6EFA /* PBXTextBookmark */ = 6184DF8A117973D500AF6EFA /* PBXTextBookmark */; - 6184DF8D117973FB00AF6EFA /* PBXBookmark */ = 6184DF8D117973FB00AF6EFA /* PBXBookmark */; - 6184DF9A1179752300AF6EFA /* PBXTextBookmark */ = 6184DF9A1179752300AF6EFA /* PBXTextBookmark */; - 6184DF9B1179752300AF6EFA /* PBXTextBookmark */ = 6184DF9B1179752300AF6EFA /* PBXTextBookmark */; - 6184DF9C1179752300AF6EFA /* PBXTextBookmark */ = 6184DF9C1179752300AF6EFA /* PBXTextBookmark */; - 6184DF9D1179752300AF6EFA /* PBXTextBookmark */ = 6184DF9D1179752300AF6EFA /* PBXTextBookmark */; - 6184DF9E1179752300AF6EFA /* PBXTextBookmark */ = 6184DF9E1179752300AF6EFA /* PBXTextBookmark */; - 6184DFA11179752300AF6EFA /* PBXTextBookmark */ = 6184DFA11179752300AF6EFA /* PBXTextBookmark */; - 6184DFA21179752300AF6EFA /* PBXTextBookmark */ = 6184DFA21179752300AF6EFA /* PBXTextBookmark */; - 6184DFA31179752300AF6EFA /* PBXTextBookmark */ = 6184DFA31179752300AF6EFA /* PBXTextBookmark */; - 6184DFA41179752300AF6EFA /* PBXTextBookmark */ = 6184DFA41179752300AF6EFA /* PBXTextBookmark */; - 6184DFAA1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAA1179762800AF6EFA /* PBXTextBookmark */; - 6184DFAB1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAB1179762800AF6EFA /* PBXTextBookmark */; - 6184DFAC1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAC1179762800AF6EFA /* PBXTextBookmark */; - 6184DFAD1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAD1179762800AF6EFA /* PBXTextBookmark */; - 6184DFAE1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAE1179762800AF6EFA /* PBXTextBookmark */; - 6184DFAF1179762800AF6EFA /* PBXTextBookmark */ = 6184DFAF1179762800AF6EFA /* PBXTextBookmark */; - 6184DFB3117979AB00AF6EFA /* PBXTextBookmark */ = 6184DFB3117979AB00AF6EFA /* PBXTextBookmark */; - 6184DFB4117979AB00AF6EFA /* PBXTextBookmark */ = 6184DFB4117979AB00AF6EFA /* PBXTextBookmark */; - 6184DFB5117979AB00AF6EFA /* PBXTextBookmark */ = 6184DFB5117979AB00AF6EFA /* PBXTextBookmark */; - 6184DFBA117979EC00AF6EFA /* PBXTextBookmark */ = 6184DFBA117979EC00AF6EFA /* PBXTextBookmark */; - 6184DFBB117979EC00AF6EFA /* PBXTextBookmark */ = 6184DFBB117979EC00AF6EFA /* PBXTextBookmark */; - 6184DFBC117979EC00AF6EFA /* PBXTextBookmark */ = 6184DFBC117979EC00AF6EFA /* PBXTextBookmark */; - 6184DFBE117979FE00AF6EFA /* PBXBookmark */ = 6184DFBE117979FE00AF6EFA /* PBXBookmark */; - 6184DFC111797A1500AF6EFA /* PBXTextBookmark */ = 6184DFC111797A1500AF6EFA /* PBXTextBookmark */; - 6184DFC211797A1500AF6EFA /* PBXTextBookmark */ = 6184DFC211797A1500AF6EFA /* PBXTextBookmark */; - 6184DFC511797A1500AF6EFA /* PBXTextBookmark */ = 6184DFC511797A1500AF6EFA /* PBXTextBookmark */; - 6184DFC611797A1500AF6EFA /* PBXTextBookmark */ = 6184DFC611797A1500AF6EFA /* PBXTextBookmark */; - 6184DFCB11797A4900AF6EFA /* PBXTextBookmark */ = 6184DFCB11797A4900AF6EFA /* PBXTextBookmark */; - 6184DFCC11797A4900AF6EFA /* PBXTextBookmark */ = 6184DFCC11797A4900AF6EFA /* PBXTextBookmark */; - 6184DFCD11797A4900AF6EFA /* PBXTextBookmark */ = 6184DFCD11797A4900AF6EFA /* PBXTextBookmark */; - 6184DFCE11797A4900AF6EFA /* PBXTextBookmark */ = 6184DFCE11797A4900AF6EFA /* PBXTextBookmark */; - 6184DFD011797AAC00AF6EFA /* PBXBookmark */ = 6184DFD011797AAC00AF6EFA /* PBXBookmark */; - 6184DFD311797AE500AF6EFA /* PBXTextBookmark */ = 6184DFD311797AE500AF6EFA /* PBXTextBookmark */; - 6184DFD411797AE500AF6EFA /* PBXTextBookmark */ = 6184DFD411797AE500AF6EFA /* PBXTextBookmark */; - 6184DFD511797AE500AF6EFA /* PBXTextBookmark */ = 6184DFD511797AE500AF6EFA /* PBXTextBookmark */; - 6184DFD811797AE500AF6EFA /* PBXTextBookmark */ = 6184DFD811797AE500AF6EFA /* PBXTextBookmark */; - 6184DFD911797AE500AF6EFA /* PBXTextBookmark */ = 6184DFD911797AE500AF6EFA /* PBXTextBookmark */; - 6184DFDF11797C6600AF6EFA /* PBXTextBookmark */ = 6184DFDF11797C6600AF6EFA /* PBXTextBookmark */; - 6184DFE111797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE111797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE211797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE211797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE311797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE311797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE611797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE611797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE711797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE711797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE811797D2500AF6EFA /* PBXTextBookmark */ = 6184DFE811797D2500AF6EFA /* PBXTextBookmark */; - 6184DFE911797D3C00AF6EFA /* PBXTextBookmark */ = 6184DFE911797D3C00AF6EFA /* PBXTextBookmark */; - 6184DFEA11797D3C00AF6EFA /* PBXTextBookmark */ = 6184DFEA11797D3C00AF6EFA /* PBXTextBookmark */; - 6184DFEB11797D3C00AF6EFA /* PBXTextBookmark */ = 6184DFEB11797D3C00AF6EFA /* PBXTextBookmark */; - 6184DFF211797D7C00AF6EFA /* PBXTextBookmark */ = 6184DFF211797D7C00AF6EFA /* PBXTextBookmark */; - 6184DFF31179809400AF6EFA /* PBXTextBookmark */ = 6184DFF31179809400AF6EFA /* PBXTextBookmark */; - 6184DFF41179809400AF6EFA /* PBXTextBookmark */ = 6184DFF41179809400AF6EFA /* PBXTextBookmark */; - 6184DFF51179809400AF6EFA /* XCBuildMessageTextBookmark */ = 6184DFF51179809400AF6EFA /* XCBuildMessageTextBookmark */; - 6184DFF61179809400AF6EFA /* PBXTextBookmark */ = 6184DFF61179809400AF6EFA /* PBXTextBookmark */; - 6184DFF71179809A00AF6EFA /* PBXTextBookmark */ = 6184DFF71179809A00AF6EFA /* PBXTextBookmark */; - 6184DFF81179809B00AF6EFA /* PBXTextBookmark */ = 6184DFF81179809B00AF6EFA /* PBXTextBookmark */; + 6184DE111178F46B00AF6EFA = 6184DE111178F46B00AF6EFA /* PBXTextBookmark */; + 6184DE1D1178F4B900AF6EFA = 6184DE1D1178F4B900AF6EFA /* PBXTextBookmark */; + 6184DE201178F4BD00AF6EFA = 6184DE201178F4BD00AF6EFA /* PBXTextBookmark */; + 6184DE211178F4BD00AF6EFA = 6184DE211178F4BD00AF6EFA /* PBXTextBookmark */; + 6184DE221178F4BD00AF6EFA = 6184DE221178F4BD00AF6EFA /* PBXTextBookmark */; + 6184DE251178F4BD00AF6EFA = 6184DE251178F4BD00AF6EFA /* PBXTextBookmark */; + 6184DE261178F4BD00AF6EFA = 6184DE261178F4BD00AF6EFA /* PBXTextBookmark */; + 6184DE341178F56B00AF6EFA = 6184DE341178F56B00AF6EFA /* PBXTextBookmark */; + 6184DE351178F56B00AF6EFA = 6184DE351178F56B00AF6EFA /* PBXTextBookmark */; + 6184DE3B1178F5BA00AF6EFA = 6184DE3B1178F5BA00AF6EFA /* PBXTextBookmark */; + 6184DE3C1178F5BA00AF6EFA = 6184DE3C1178F5BA00AF6EFA /* PBXTextBookmark */; + 6184DE401178F5C400AF6EFA = 6184DE401178F5C400AF6EFA /* PBXTextBookmark */; + 6184DE411178F5C400AF6EFA = 6184DE411178F5C400AF6EFA /* PBXTextBookmark */; + 6184DE471178F68C00AF6EFA = 6184DE471178F68C00AF6EFA /* PBXTextBookmark */; + 6184DE481178F68C00AF6EFA = 6184DE481178F68C00AF6EFA /* PBXTextBookmark */; + 6184DE4D1178F6F200AF6EFA = 6184DE4D1178F6F200AF6EFA /* PBXTextBookmark */; + 6184DE4E1178F6F200AF6EFA = 6184DE4E1178F6F200AF6EFA /* PBXTextBookmark */; + 6184DE521178F72200AF6EFA = 6184DE521178F72200AF6EFA /* PBXTextBookmark */; + 6184DE531178F72200AF6EFA = 6184DE531178F72200AF6EFA /* PBXTextBookmark */; + 6184DE5A1178F75E00AF6EFA = 6184DE5A1178F75E00AF6EFA /* PBXTextBookmark */; + 6184DE5B1178F75E00AF6EFA = 6184DE5B1178F75E00AF6EFA /* PBXTextBookmark */; + 6184DE5E1178F7D700AF6EFA = 6184DE5E1178F7D700AF6EFA /* PBXTextBookmark */; + 6184DE5F1178F7D700AF6EFA = 6184DE5F1178F7D700AF6EFA /* PBXTextBookmark */; + 6184DE631178F80E00AF6EFA = 6184DE631178F80E00AF6EFA /* PBXTextBookmark */; + 6184DE641178F80E00AF6EFA = 6184DE641178F80E00AF6EFA /* PBXTextBookmark */; + 6184DE681178F84100AF6EFA = 6184DE681178F84100AF6EFA /* PBXTextBookmark */; + 6184DE691178F84100AF6EFA = 6184DE691178F84100AF6EFA /* PBXTextBookmark */; + 6184DE6F117901F600AF6EFA = 6184DE6F117901F600AF6EFA /* PBXBookmark */; + 6184DE7511795AEE00AF6EFA = 6184DE7511795AEE00AF6EFA /* PBXBookmark */; + 6184DE7E11795D3F00AF6EFA = 6184DE7E11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE7F11795D3F00AF6EFA = 6184DE7F11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8011795D3F00AF6EFA = 6184DE8011795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8111795D3F00AF6EFA = 6184DE8111795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8211795D3F00AF6EFA = 6184DE8211795D3F00AF6EFA /* PBXBookmark */; + 6184DE8311795D3F00AF6EFA = 6184DE8311795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8611795D3F00AF6EFA = 6184DE8611795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8911795D3F00AF6EFA = 6184DE8911795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8A11795D3F00AF6EFA = 6184DE8A11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8B11795D3F00AF6EFA = 6184DE8B11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8E11795D3F00AF6EFA = 6184DE8E11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE8F11795D3F00AF6EFA = 6184DE8F11795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE9011795D3F00AF6EFA = 6184DE9011795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE9311795D3F00AF6EFA = 6184DE9311795D3F00AF6EFA /* PBXTextBookmark */; + 6184DE9511795D6700AF6EFA = 6184DE9511795D6700AF6EFA /* PBXTextBookmark */; + 6184DE9611795D6700AF6EFA = 6184DE9611795D6700AF6EFA /* PBXTextBookmark */; + 6184DE9711795D6700AF6EFA = 6184DE9711795D6700AF6EFA /* PBXTextBookmark */; + 6184DE9811795D6700AF6EFA = 6184DE9811795D6700AF6EFA /* PBXTextBookmark */; + 6184DE9911795D6700AF6EFA = 6184DE9911795D6700AF6EFA /* PBXTextBookmark */; + 6184DE9C11795DA500AF6EFA = 6184DE9C11795DA500AF6EFA /* PBXTextBookmark */; + 6184DE9D11795DA500AF6EFA = 6184DE9D11795DA500AF6EFA /* PBXTextBookmark */; + 6184DE9E11795DA500AF6EFA = 6184DE9E11795DA500AF6EFA /* PBXTextBookmark */; + 6184DE9F11795DA500AF6EFA = 6184DE9F11795DA500AF6EFA /* PBXTextBookmark */; + 6184DEA011795DA500AF6EFA = 6184DEA011795DA500AF6EFA /* PBXTextBookmark */; + 6184DEAF11795FC700AF6EFA = 6184DEAF11795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB011795FC700AF6EFA = 6184DEB011795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB111795FC700AF6EFA = 6184DEB111795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB211795FC700AF6EFA = 6184DEB211795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB311795FC700AF6EFA = 6184DEB311795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB611795FC700AF6EFA = 6184DEB611795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB711795FC700AF6EFA = 6184DEB711795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB811795FC700AF6EFA = 6184DEB811795FC700AF6EFA /* PBXTextBookmark */; + 6184DEB911795FC700AF6EFA = 6184DEB911795FC700AF6EFA /* PBXTextBookmark */; + 6184DEBA11795FC700AF6EFA = 6184DEBA11795FC700AF6EFA /* PBXTextBookmark */; + 6184DEBF1179604200AF6EFA = 6184DEBF1179604200AF6EFA /* PBXTextBookmark */; + 6184DEC01179604200AF6EFA = 6184DEC01179604200AF6EFA /* PBXTextBookmark */; + 6184DEC11179604200AF6EFA = 6184DEC11179604200AF6EFA /* PBXTextBookmark */; + 6184DEC21179604200AF6EFA = 6184DEC21179604200AF6EFA /* PBXTextBookmark */; + 6184DEC31179604200AF6EFA = 6184DEC31179604200AF6EFA /* PBXTextBookmark */; + 6184DECB1179609000AF6EFA = 6184DECB1179609000AF6EFA /* PBXTextBookmark */; + 6184DECC1179609000AF6EFA = 6184DECC1179609000AF6EFA /* PBXTextBookmark */; + 6184DECD1179609000AF6EFA = 6184DECD1179609000AF6EFA /* PBXTextBookmark */; + 6184DECE1179609000AF6EFA = 6184DECE1179609000AF6EFA /* PBXTextBookmark */; + 6184DECF1179609000AF6EFA = 6184DECF1179609000AF6EFA /* PBXTextBookmark */; + 6184DED71179629900AF6EFA = 6184DED71179629900AF6EFA /* PBXTextBookmark */; + 6184DED81179629900AF6EFA = 6184DED81179629900AF6EFA /* PBXTextBookmark */; + 6184DED91179629900AF6EFA = 6184DED91179629900AF6EFA /* PBXTextBookmark */; + 6184DEDA1179629900AF6EFA = 6184DEDA1179629900AF6EFA /* PBXTextBookmark */; + 6184DEDB1179629900AF6EFA = 6184DEDB1179629900AF6EFA /* PBXTextBookmark */; + 6184DEDC1179629900AF6EFA = 6184DEDC1179629900AF6EFA /* PBXTextBookmark */; + 6184DEDD1179629900AF6EFA = 6184DEDD1179629900AF6EFA /* PBXTextBookmark */; + 6184DEE11179634500AF6EFA = 6184DEE11179634500AF6EFA /* PBXTextBookmark */; + 6184DEE21179634500AF6EFA = 6184DEE21179634500AF6EFA /* PBXTextBookmark */; + 6184DEE31179634500AF6EFA = 6184DEE31179634500AF6EFA /* PBXTextBookmark */; + 6184DEE41179634500AF6EFA = 6184DEE41179634500AF6EFA /* PBXTextBookmark */; + 6184DEE51179634500AF6EFA = 6184DEE51179634500AF6EFA /* PBXTextBookmark */; + 6184DEE91179637C00AF6EFA = 6184DEE91179637C00AF6EFA /* PBXTextBookmark */; + 6184DEEA1179637C00AF6EFA = 6184DEEA1179637C00AF6EFA /* PBXTextBookmark */; + 6184DEEB1179637C00AF6EFA = 6184DEEB1179637C00AF6EFA /* PBXTextBookmark */; + 6184DEEC1179637C00AF6EFA = 6184DEEC1179637C00AF6EFA /* PBXTextBookmark */; + 6184DEED1179637C00AF6EFA = 6184DEED1179637C00AF6EFA /* PBXTextBookmark */; + 6184DEEF1179639700AF6EFA = 6184DEEF1179639700AF6EFA /* PBXTextBookmark */; + 6184DEF01179639700AF6EFA = 6184DEF01179639700AF6EFA /* PBXTextBookmark */; + 6184DEF11179639700AF6EFA = 6184DEF11179639700AF6EFA /* PBXTextBookmark */; + 6184DEF21179639700AF6EFA = 6184DEF21179639700AF6EFA /* PBXTextBookmark */; + 6184DEF31179639700AF6EFA = 6184DEF31179639700AF6EFA /* PBXTextBookmark */; + 6184DEF61179659200AF6EFA = 6184DEF61179659200AF6EFA /* PBXTextBookmark */; + 6184DEF71179659200AF6EFA = 6184DEF71179659200AF6EFA /* PBXTextBookmark */; + 6184DEF81179659200AF6EFA = 6184DEF81179659200AF6EFA /* PBXTextBookmark */; + 6184DEF91179659200AF6EFA = 6184DEF91179659200AF6EFA /* PBXTextBookmark */; + 6184DEFA1179659200AF6EFA = 6184DEFA1179659200AF6EFA /* PBXTextBookmark */; + 6184DEFB1179659200AF6EFA = 6184DEFB1179659200AF6EFA /* PBXTextBookmark */; + 6184DEFC1179659200AF6EFA = 6184DEFC1179659200AF6EFA /* PBXTextBookmark */; + 6184DF001179666500AF6EFA = 6184DF001179666500AF6EFA /* PBXTextBookmark */; + 6184DF011179666500AF6EFA = 6184DF011179666500AF6EFA /* PBXTextBookmark */; + 6184DF021179666500AF6EFA = 6184DF021179666500AF6EFA /* PBXTextBookmark */; + 6184DF031179666500AF6EFA = 6184DF031179666500AF6EFA /* PBXTextBookmark */; + 6184DF041179666500AF6EFA = 6184DF041179666500AF6EFA /* PBXTextBookmark */; + 6184DF06117966F400AF6EFA = 6184DF06117966F400AF6EFA /* PBXTextBookmark */; + 6184DF07117966F400AF6EFA = 6184DF07117966F400AF6EFA /* PBXTextBookmark */; + 6184DF08117966F400AF6EFA = 6184DF08117966F400AF6EFA /* PBXTextBookmark */; + 6184DF09117966F700AF6EFA = 6184DF09117966F700AF6EFA /* PBXBookmark */; + 6184DF10117967DC00AF6EFA = 6184DF10117967DC00AF6EFA /* PBXTextBookmark */; + 6184DF11117967DC00AF6EFA = 6184DF11117967DC00AF6EFA /* PBXTextBookmark */; + 6184DF14117967DC00AF6EFA = 6184DF14117967DC00AF6EFA /* PBXTextBookmark */; + 6184DF15117967DC00AF6EFA = 6184DF15117967DC00AF6EFA /* PBXTextBookmark */; + 6184DF191179680800AF6EFA = 6184DF191179680800AF6EFA /* PBXTextBookmark */; + 6184DF1A1179680800AF6EFA = 6184DF1A1179680800AF6EFA /* PBXTextBookmark */; + 6184DF1B1179680800AF6EFA = 6184DF1B1179680800AF6EFA /* PBXTextBookmark */; + 6184DF1D1179688500AF6EFA = 6184DF1D1179688500AF6EFA /* PBXBookmark */; + 6184DF1E117968A500AF6EFA = 6184DF1E117968A500AF6EFA /* PBXBookmark */; + 6184DF231179691200AF6EFA = 6184DF231179691200AF6EFA /* PBXTextBookmark */; + 6184DF261179691200AF6EFA = 6184DF261179691200AF6EFA /* PBXTextBookmark */; + 6184DF271179691200AF6EFA = 6184DF271179691200AF6EFA /* PBXTextBookmark */; + 6184DF2A1179691200AF6EFA = 6184DF2A1179691200AF6EFA /* PBXTextBookmark */; + 6184DF2C1179691D00AF6EFA = 6184DF2C1179691D00AF6EFA /* PBXTextBookmark */; + 6184DF2D1179691D00AF6EFA = 6184DF2D1179691D00AF6EFA /* PBXTextBookmark */; + 6184DF2E1179691D00AF6EFA = 6184DF2E1179691D00AF6EFA /* PBXTextBookmark */; + 6184DF2F1179691D00AF6EFA = 6184DF2F1179691D00AF6EFA /* PBXTextBookmark */; + 6184DF34117969EF00AF6EFA = 6184DF34117969EF00AF6EFA /* PBXTextBookmark */; + 6184DF35117969EF00AF6EFA = 6184DF35117969EF00AF6EFA /* PBXTextBookmark */; + 6184DF36117969EF00AF6EFA = 6184DF36117969EF00AF6EFA /* PBXTextBookmark */; + 6184DF37117969EF00AF6EFA = 6184DF37117969EF00AF6EFA /* PBXTextBookmark */; + 6184DF3B117969FF00AF6EFA = 6184DF3B117969FF00AF6EFA /* PBXTextBookmark */; + 6184DF3C117969FF00AF6EFA = 6184DF3C117969FF00AF6EFA /* PBXTextBookmark */; + 6184DF3D117969FF00AF6EFA = 6184DF3D117969FF00AF6EFA /* PBXTextBookmark */; + 6184DF3E117969FF00AF6EFA = 6184DF3E117969FF00AF6EFA /* PBXTextBookmark */; + 6184DF4011796A3200AF6EFA = 6184DF4011796A3200AF6EFA /* PBXBookmark */; + 6184DF4111796A6400AF6EFA = 6184DF4111796A6400AF6EFA /* PBXBookmark */; + 6184DF4411796A9200AF6EFA = 6184DF4411796A9200AF6EFA /* PBXTextBookmark */; + 6184DF4511796A9200AF6EFA = 6184DF4511796A9200AF6EFA /* PBXTextBookmark */; + 6184DF4611796A9300AF6EFA = 6184DF4611796A9300AF6EFA /* PBXTextBookmark */; + 6184DF4911796A9300AF6EFA = 6184DF4911796A9300AF6EFA /* PBXTextBookmark */; + 6184DF4C11796A9300AF6EFA = 6184DF4C11796A9300AF6EFA /* PBXTextBookmark */; + 6184DF4D11796A9300AF6EFA = 6184DF4D11796A9300AF6EFA /* PBXTextBookmark */; + 6184DF4E11796A9300AF6EFA = 6184DF4E11796A9300AF6EFA /* PBXTextBookmark */; + 6184DF4F11796A9300AF6EFA = 6184DF4F11796A9300AF6EFA /* PBXTextBookmark */; + 6184DF6F117972FE00AF6EFA = 6184DF6F117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF70117972FE00AF6EFA = 6184DF70117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF71117972FE00AF6EFA = 6184DF71117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF72117972FE00AF6EFA = 6184DF72117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF73117972FE00AF6EFA = 6184DF73117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF74117972FE00AF6EFA = 6184DF74117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF75117972FE00AF6EFA = 6184DF75117972FE00AF6EFA /* PBXTextBookmark */; + 6184DF77117973AF00AF6EFA = 6184DF77117973AF00AF6EFA /* PBXTextBookmark */; + 6184DF78117973AF00AF6EFA = 6184DF78117973AF00AF6EFA /* PBXTextBookmark */; + 6184DF79117973AF00AF6EFA = 6184DF79117973AF00AF6EFA /* PBXTextBookmark */; + 6184DF7A117973AF00AF6EFA = 6184DF7A117973AF00AF6EFA /* PBXTextBookmark */; + 6184DF7B117973AF00AF6EFA = 6184DF7B117973AF00AF6EFA /* PBXTextBookmark */; + 6184DF7C117973BF00AF6EFA = 6184DF7C117973BF00AF6EFA /* PBXTextBookmark */; + 6184DF7D117973BF00AF6EFA = 6184DF7D117973BF00AF6EFA /* PBXTextBookmark */; + 6184DF7E117973BF00AF6EFA = 6184DF7E117973BF00AF6EFA /* PBXTextBookmark */; + 6184DF7F117973BF00AF6EFA = 6184DF7F117973BF00AF6EFA /* PBXTextBookmark */; + 6184DF80117973BF00AF6EFA = 6184DF80117973BF00AF6EFA /* PBXTextBookmark */; + 6184DF81117973CC00AF6EFA = 6184DF81117973CC00AF6EFA /* PBXTextBookmark */; + 6184DF82117973CC00AF6EFA = 6184DF82117973CC00AF6EFA /* PBXTextBookmark */; + 6184DF83117973CC00AF6EFA = 6184DF83117973CC00AF6EFA /* PBXTextBookmark */; + 6184DF84117973CC00AF6EFA = 6184DF84117973CC00AF6EFA /* PBXTextBookmark */; + 6184DF85117973CC00AF6EFA = 6184DF85117973CC00AF6EFA /* PBXTextBookmark */; + 6184DF86117973D500AF6EFA = 6184DF86117973D500AF6EFA /* PBXTextBookmark */; + 6184DF87117973D500AF6EFA = 6184DF87117973D500AF6EFA /* PBXTextBookmark */; + 6184DF88117973D500AF6EFA = 6184DF88117973D500AF6EFA /* PBXTextBookmark */; + 6184DF89117973D500AF6EFA = 6184DF89117973D500AF6EFA /* PBXTextBookmark */; + 6184DF8A117973D500AF6EFA = 6184DF8A117973D500AF6EFA /* PBXTextBookmark */; + 6184DF8D117973FB00AF6EFA = 6184DF8D117973FB00AF6EFA /* PBXBookmark */; + 6184DF9A1179752300AF6EFA = 6184DF9A1179752300AF6EFA /* PBXTextBookmark */; + 6184DF9B1179752300AF6EFA = 6184DF9B1179752300AF6EFA /* PBXTextBookmark */; + 6184DF9C1179752300AF6EFA = 6184DF9C1179752300AF6EFA /* PBXTextBookmark */; + 6184DF9D1179752300AF6EFA = 6184DF9D1179752300AF6EFA /* PBXTextBookmark */; + 6184DF9E1179752300AF6EFA = 6184DF9E1179752300AF6EFA /* PBXTextBookmark */; + 6184DFA11179752300AF6EFA = 6184DFA11179752300AF6EFA /* PBXTextBookmark */; + 6184DFA21179752300AF6EFA = 6184DFA21179752300AF6EFA /* PBXTextBookmark */; + 6184DFA31179752300AF6EFA = 6184DFA31179752300AF6EFA /* PBXTextBookmark */; + 6184DFA41179752300AF6EFA = 6184DFA41179752300AF6EFA /* PBXTextBookmark */; + 6184DFAA1179762800AF6EFA = 6184DFAA1179762800AF6EFA /* PBXTextBookmark */; + 6184DFAB1179762800AF6EFA = 6184DFAB1179762800AF6EFA /* PBXTextBookmark */; + 6184DFAC1179762800AF6EFA = 6184DFAC1179762800AF6EFA /* PBXTextBookmark */; + 6184DFAD1179762800AF6EFA = 6184DFAD1179762800AF6EFA /* PBXTextBookmark */; + 6184DFAE1179762800AF6EFA = 6184DFAE1179762800AF6EFA /* PBXTextBookmark */; + 6184DFAF1179762800AF6EFA = 6184DFAF1179762800AF6EFA /* PBXTextBookmark */; + 6184DFB3117979AB00AF6EFA = 6184DFB3117979AB00AF6EFA /* PBXTextBookmark */; + 6184DFB4117979AB00AF6EFA = 6184DFB4117979AB00AF6EFA /* PBXTextBookmark */; + 6184DFB5117979AB00AF6EFA = 6184DFB5117979AB00AF6EFA /* PBXTextBookmark */; + 6184DFBA117979EC00AF6EFA = 6184DFBA117979EC00AF6EFA /* PBXTextBookmark */; + 6184DFBB117979EC00AF6EFA = 6184DFBB117979EC00AF6EFA /* PBXTextBookmark */; + 6184DFBC117979EC00AF6EFA = 6184DFBC117979EC00AF6EFA /* PBXTextBookmark */; + 6184DFBE117979FE00AF6EFA = 6184DFBE117979FE00AF6EFA /* PBXBookmark */; + 6184DFC111797A1500AF6EFA = 6184DFC111797A1500AF6EFA /* PBXTextBookmark */; + 6184DFC211797A1500AF6EFA = 6184DFC211797A1500AF6EFA /* PBXTextBookmark */; + 6184DFC511797A1500AF6EFA = 6184DFC511797A1500AF6EFA /* PBXTextBookmark */; + 6184DFC611797A1500AF6EFA = 6184DFC611797A1500AF6EFA /* PBXTextBookmark */; + 6184DFCB11797A4900AF6EFA = 6184DFCB11797A4900AF6EFA /* PBXTextBookmark */; + 6184DFCC11797A4900AF6EFA = 6184DFCC11797A4900AF6EFA /* PBXTextBookmark */; + 6184DFCD11797A4900AF6EFA = 6184DFCD11797A4900AF6EFA /* PBXTextBookmark */; + 6184DFCE11797A4900AF6EFA = 6184DFCE11797A4900AF6EFA /* PBXTextBookmark */; + 6184DFD011797AAC00AF6EFA = 6184DFD011797AAC00AF6EFA /* PBXBookmark */; + 6184DFD311797AE500AF6EFA = 6184DFD311797AE500AF6EFA /* PBXTextBookmark */; + 6184DFD411797AE500AF6EFA = 6184DFD411797AE500AF6EFA /* PBXTextBookmark */; + 6184DFD511797AE500AF6EFA = 6184DFD511797AE500AF6EFA /* PBXTextBookmark */; + 6184DFD811797AE500AF6EFA = 6184DFD811797AE500AF6EFA /* PBXTextBookmark */; + 6184DFD911797AE500AF6EFA = 6184DFD911797AE500AF6EFA /* PBXTextBookmark */; + 6184DFDF11797C6600AF6EFA = 6184DFDF11797C6600AF6EFA /* PBXTextBookmark */; + 6184DFE111797D2500AF6EFA = 6184DFE111797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE211797D2500AF6EFA = 6184DFE211797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE311797D2500AF6EFA = 6184DFE311797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE611797D2500AF6EFA = 6184DFE611797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE711797D2500AF6EFA = 6184DFE711797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE811797D2500AF6EFA = 6184DFE811797D2500AF6EFA /* PBXTextBookmark */; + 6184DFE911797D3C00AF6EFA = 6184DFE911797D3C00AF6EFA /* PBXTextBookmark */; + 6184DFEA11797D3C00AF6EFA = 6184DFEA11797D3C00AF6EFA /* PBXTextBookmark */; + 6184DFEB11797D3C00AF6EFA = 6184DFEB11797D3C00AF6EFA /* PBXTextBookmark */; + 6184DFF211797D7C00AF6EFA = 6184DFF211797D7C00AF6EFA /* PBXTextBookmark */; + 6184DFF31179809400AF6EFA = 6184DFF31179809400AF6EFA /* PBXTextBookmark */; + 6184DFF41179809400AF6EFA = 6184DFF41179809400AF6EFA /* PBXTextBookmark */; + 6184DFF51179809400AF6EFA = 6184DFF51179809400AF6EFA /* PBXTextBookmark */; + 6184DFF61179809400AF6EFA = 6184DFF61179809400AF6EFA /* PBXTextBookmark */; + 6184DFF71179809A00AF6EFA = 6184DFF71179809A00AF6EFA /* PBXTextBookmark */; + 6184DFF81179809B00AF6EFA = 6184DFF81179809B00AF6EFA /* PBXTextBookmark */; 6188FE60116F77AF004F3690 = 6188FE60116F77AF004F3690 /* PBXTextBookmark */; 618AFC07115BE92A003D411B = 618AFC07115BE92A003D411B /* PBXBookmark */; 618BE56511750F6B00F22556 = 618BE56511750F6B00F22556 /* PBXTextBookmark */; @@ -506,6 +506,78 @@ 619C58B2116E76080049FD84 = 619C58B2116E76080049FD84 /* PBXBookmark */; 619C58B3116E76080049FD84 = 619C58B3116E76080049FD84 /* PBXTextBookmark */; 61BD54C411789A020038D495 = 61BD54C411789A020038D495 /* PBXTextBookmark */; + 61C325231179A314001E70B1 /* PBXTextBookmark */ = 61C325231179A314001E70B1 /* PBXTextBookmark */; + 61C325241179A314001E70B1 /* PBXBookmark */ = 61C325241179A314001E70B1 /* PBXBookmark */; + 61C325251179A314001E70B1 /* PBXTextBookmark */ = 61C325251179A314001E70B1 /* PBXTextBookmark */; + 61C325381179A32A001E70B1 /* PBXTextBookmark */ = 61C325381179A32A001E70B1 /* PBXTextBookmark */; + 61C325681179A3A0001E70B1 /* PBXTextBookmark */ = 61C325681179A3A0001E70B1 /* PBXTextBookmark */; + 61C325691179A3A0001E70B1 /* PBXTextBookmark */ = 61C325691179A3A0001E70B1 /* PBXTextBookmark */; + 61C3256A1179A3A0001E70B1 /* XCBuildMessageTextBookmark */ = 61C3256A1179A3A0001E70B1 /* XCBuildMessageTextBookmark */; + 61C3256B1179A3A0001E70B1 /* PBXTextBookmark */ = 61C3256B1179A3A0001E70B1 /* PBXTextBookmark */; + 61C325701179A405001E70B1 /* PBXTextBookmark */ = 61C325701179A405001E70B1 /* PBXTextBookmark */; + 61C3257C1179A4AD001E70B1 /* PBXTextBookmark */ = 61C3257C1179A4AD001E70B1 /* PBXTextBookmark */; + 61C3257D1179A4AD001E70B1 /* PBXTextBookmark */ = 61C3257D1179A4AD001E70B1 /* PBXTextBookmark */; + 61C3257E1179A4AD001E70B1 /* XCBuildMessageTextBookmark */ = 61C3257E1179A4AD001E70B1 /* XCBuildMessageTextBookmark */; + 61C3257F1179A4AD001E70B1 /* PBXTextBookmark */ = 61C3257F1179A4AD001E70B1 /* PBXTextBookmark */; + 61C325891179A593001E70B1 /* PBXBookmark */ = 61C325891179A593001E70B1 /* PBXBookmark */; + 61C325941179A75D001E70B1 /* PBXTextBookmark */ = 61C325941179A75D001E70B1 /* PBXTextBookmark */; + 61C325951179A75D001E70B1 /* XCBuildMessageTextBookmark */ = 61C325951179A75D001E70B1 /* XCBuildMessageTextBookmark */; + 61C325961179A75D001E70B1 /* PBXTextBookmark */ = 61C325961179A75D001E70B1 /* PBXTextBookmark */; + 61C325991179A75D001E70B1 /* PBXTextBookmark */ = 61C325991179A75D001E70B1 /* PBXTextBookmark */; + 61C3259A1179A75D001E70B1 /* PBXTextBookmark */ = 61C3259A1179A75D001E70B1 /* PBXTextBookmark */; + 61C3259B1179A75D001E70B1 /* PBXTextBookmark */ = 61C3259B1179A75D001E70B1 /* PBXTextBookmark */; + 61C3259E1179A75D001E70B1 /* PBXTextBookmark */ = 61C3259E1179A75D001E70B1 /* PBXTextBookmark */; + 61C325AB1179A88A001E70B1 /* PBXTextBookmark */ = 61C325AB1179A88A001E70B1 /* PBXTextBookmark */; + 61C325AC1179A88A001E70B1 /* PBXTextBookmark */ = 61C325AC1179A88A001E70B1 /* PBXTextBookmark */; + 61C325AD1179A88A001E70B1 /* PBXTextBookmark */ = 61C325AD1179A88A001E70B1 /* PBXTextBookmark */; + 61C325B91179A8E0001E70B1 /* PBXTextBookmark */ = 61C325B91179A8E0001E70B1 /* PBXTextBookmark */; + 61C325BA1179A8E0001E70B1 /* PBXTextBookmark */ = 61C325BA1179A8E0001E70B1 /* PBXTextBookmark */; + 61C325BB1179A8E0001E70B1 /* PBXTextBookmark */ = 61C325BB1179A8E0001E70B1 /* PBXTextBookmark */; + 61C325BC1179A8E0001E70B1 /* PBXTextBookmark */ = 61C325BC1179A8E0001E70B1 /* PBXTextBookmark */; + 61C325BD1179A8E0001E70B1 /* PBXTextBookmark */ = 61C325BD1179A8E0001E70B1 /* PBXTextBookmark */; + 61C325BF1179A8E0001E70B1 /* PBXTextBookmark */ = 61C325BF1179A8E0001E70B1 /* PBXTextBookmark */; + 61C325C01179A8E0001E70B1 /* XCBuildMessageTextBookmark */ = 61C325C01179A8E0001E70B1 /* XCBuildMessageTextBookmark */; + 61C325C11179A8E0001E70B1 /* PBXTextBookmark */ = 61C325C11179A8E0001E70B1 /* PBXTextBookmark */; + 61C325C21179A8E0001E70B1 /* PBXTextBookmark */ = 61C325C21179A8E0001E70B1 /* PBXTextBookmark */; + 61C325C31179A8E0001E70B1 /* PBXTextBookmark */ = 61C325C31179A8E0001E70B1 /* PBXTextBookmark */; + 61C325C41179A8E0001E70B1 /* PBXTextBookmark */ = 61C325C41179A8E0001E70B1 /* PBXTextBookmark */; + 61C325C91179A8F9001E70B1 /* PBXTextBookmark */ = 61C325C91179A8F9001E70B1 /* PBXTextBookmark */; + 61C325CA1179A8F9001E70B1 /* PBXTextBookmark */ = 61C325CA1179A8F9001E70B1 /* PBXTextBookmark */; + 61C325CB1179A8F9001E70B1 /* PBXTextBookmark */ = 61C325CB1179A8F9001E70B1 /* PBXTextBookmark */; + 61C325CF1179A913001E70B1 /* PBXTextBookmark */ = 61C325CF1179A913001E70B1 /* PBXTextBookmark */; + 61C325D01179A913001E70B1 /* PBXTextBookmark */ = 61C325D01179A913001E70B1 /* PBXTextBookmark */; + 61C325D41179A93D001E70B1 /* PBXTextBookmark */ = 61C325D41179A93D001E70B1 /* PBXTextBookmark */; + 61C325D51179A93D001E70B1 /* PBXTextBookmark */ = 61C325D51179A93D001E70B1 /* PBXTextBookmark */; + 61C325D61179A93D001E70B1 /* PBXTextBookmark */ = 61C325D61179A93D001E70B1 /* PBXTextBookmark */; + 61C325D71179A93D001E70B1 /* PBXTextBookmark */ = 61C325D71179A93D001E70B1 /* PBXTextBookmark */; + 61C325DA1179A97D001E70B1 /* PBXBookmark */ = 61C325DA1179A97D001E70B1 /* PBXBookmark */; + 61C325DD1179A993001E70B1 /* PBXTextBookmark */ = 61C325DD1179A993001E70B1 /* PBXTextBookmark */; + 61C325DE1179A993001E70B1 /* PBXTextBookmark */ = 61C325DE1179A993001E70B1 /* PBXTextBookmark */; + 61C325DF1179A993001E70B1 /* PBXTextBookmark */ = 61C325DF1179A993001E70B1 /* PBXTextBookmark */; + 61C325E21179A993001E70B1 /* PBXTextBookmark */ = 61C325E21179A993001E70B1 /* PBXTextBookmark */; + 61C325E31179A993001E70B1 /* PBXTextBookmark */ = 61C325E31179A993001E70B1 /* PBXTextBookmark */; + 61C325E51179AAD5001E70B1 /* PBXTextBookmark */ = 61C325E51179AAD5001E70B1 /* PBXTextBookmark */; + 61C325E61179AAD5001E70B1 /* PBXTextBookmark */ = 61C325E61179AAD5001E70B1 /* PBXTextBookmark */; + 61C325E71179AAD5001E70B1 /* PBXTextBookmark */ = 61C325E71179AAD5001E70B1 /* PBXTextBookmark */; + 61C325EA1179AB00001E70B1 /* PBXTextBookmark */ = 61C325EA1179AB00001E70B1 /* PBXTextBookmark */; + 61C325EB1179AB00001E70B1 /* PBXTextBookmark */ = 61C325EB1179AB00001E70B1 /* PBXTextBookmark */; + 61C325EC1179AB00001E70B1 /* PBXTextBookmark */ = 61C325EC1179AB00001E70B1 /* PBXTextBookmark */; + 61C325F01179ABBC001E70B1 /* PBXTextBookmark */ = 61C325F01179ABBC001E70B1 /* PBXTextBookmark */; + 61C325F11179ABBC001E70B1 /* PBXTextBookmark */ = 61C325F11179ABBC001E70B1 /* PBXTextBookmark */; + 61C325F21179ABBC001E70B1 /* PBXTextBookmark */ = 61C325F21179ABBC001E70B1 /* PBXTextBookmark */; + 61C325F61179ABFC001E70B1 /* PBXTextBookmark */ = 61C325F61179ABFC001E70B1 /* PBXTextBookmark */; + 61C325F71179ABFC001E70B1 /* PBXTextBookmark */ = 61C325F71179ABFC001E70B1 /* PBXTextBookmark */; + 61C325F81179ABFC001E70B1 /* PBXTextBookmark */ = 61C325F81179ABFC001E70B1 /* PBXTextBookmark */; + 61C325FC1179ADCA001E70B1 /* PBXTextBookmark */ = 61C325FC1179ADCA001E70B1 /* PBXTextBookmark */; + 61C325FD1179ADCA001E70B1 /* PBXTextBookmark */ = 61C325FD1179ADCA001E70B1 /* PBXTextBookmark */; + 61C325FE1179ADCA001E70B1 /* PBXTextBookmark */ = 61C325FE1179ADCA001E70B1 /* PBXTextBookmark */; + 61C326001179ADCF001E70B1 /* PBXTextBookmark */ = 61C326001179ADCF001E70B1 /* PBXTextBookmark */; + 61C326011179ADCF001E70B1 /* PBXTextBookmark */ = 61C326011179ADCF001E70B1 /* PBXTextBookmark */; + 61C326021179ADCF001E70B1 /* PBXTextBookmark */ = 61C326021179ADCF001E70B1 /* PBXTextBookmark */; + 61C326031179AE31001E70B1 /* PBXTextBookmark */ = 61C326031179AE31001E70B1 /* PBXTextBookmark */; + 61C326041179AE31001E70B1 /* PBXTextBookmark */ = 61C326041179AE31001E70B1 /* PBXTextBookmark */; + 61C326071179AEE0001E70B1 /* PBXTextBookmark */ = 61C326071179AEE0001E70B1 /* PBXTextBookmark */; + 61C326081179AEE0001E70B1 /* PBXTextBookmark */ = 61C326081179AEE0001E70B1 /* PBXTextBookmark */; 61CCBE60116135FF00833FE8 = 61CCBE60116135FF00833FE8 /* PBXTextBookmark */; 61CCBF1E116162CA00833FE8 = 61CCBF1E116162CA00833FE8 /* PBXTextBookmark */; 61CCBF451161637F00833FE8 = 61CCBF451161637F00833FE8 /* PBXTextBookmark */; @@ -732,11 +804,6 @@ name = uMisc.s; path = "/Users/vittorio/hedgewars/trunk/project_files/HedgewarsMobile/build/HedgewarsMobile.build/Debug-iphonesimulator/HedgewarsMobile.build/DerivedSources-normal/i386/uMisc.s"; sourceTree = ""; - uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {880, 73606}}"; - sepNavSelRange = "{76263, 0}"; - sepNavVisRange = "{125943, 336}"; - }; }; 61513435116C1B07001F16D1 /* PBXTextBookmark */ = { isa = PBXTextBookmark; @@ -1955,9 +2022,9 @@ }; 6184DEA211795DBD00AF6EFA /* UIImageExtra.m */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {474, 1108}}"; + sepNavIntBoundsRect = "{{0, 0}, {474, 1245}}"; sepNavSelRange = "{145, 0}"; - sepNavVisRange = "{0, 284}"; + sepNavVisRange = "{0, 246}"; sepNavWindowFrame = "{{672, 213}, {1002, 778}}"; }; }; @@ -3159,7 +3226,7 @@ rLen = 12; rLoc = 312; rType = 0; - vrLen = 586; + vrLen = 585; vrLoc = 0; }; 6184DF9D1179752300AF6EFA /* PBXTextBookmark */ = { @@ -3610,11 +3677,10 @@ vrLen = 1031; vrLoc = 16309; }; - 6184DFF51179809400AF6EFA /* XCBuildMessageTextBookmark */ = { + 6184DFF51179809400AF6EFA /* PBXTextBookmark */ = { isa = PBXTextBookmark; comments = "UIImageScale.h: No such file or directory"; fRef = 619C533D116E70050049FD84 /* FortsViewController.m */; - fallbackIsa = XCBuildMessageTextBookmark; rLen = 1; rLoc = 10; rType = 1; @@ -3685,9 +3751,9 @@ }; 618BE5911175126900F22556 /* LevelViewController.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {1027, 669}}"; + sepNavIntBoundsRect = "{{0, 0}, {474, 390}}"; sepNavSelRange = "{26, 0}"; - sepNavVisRange = "{0, 585}"; + sepNavVisRange = "{0, 274}"; }; }; 618BE5921175126900F22556 /* LevelViewController.m */ = { @@ -3765,17 +3831,17 @@ }; 618BE6A1117527CD00F22556 /* VoicesViewController.h */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {943, 650}}"; - sepNavSelRange = "{27, 0}"; - sepNavVisRange = "{0, 578}"; + sepNavIntBoundsRect = "{{0, 0}, {943, 627}}"; + sepNavSelRange = "{177, 0}"; + sepNavVisRange = "{0, 549}"; sepNavWindowFrame = "{{638, 196}, {1002, 778}}"; }; }; 618BE6A2117527CD00F22556 /* VoicesViewController.m */ = { uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {943, 2938}}"; - sepNavSelRange = "{27, 0}"; - sepNavVisRange = "{0, 1224}"; + sepNavIntBoundsRect = "{{0, 0}, {943, 3225}}"; + sepNavSelRange = "{630, 0}"; + sepNavVisRange = "{3, 1063}"; sepNavWindowFrame = "{{638, 196}, {1002, 778}}"; }; }; @@ -3892,7 +3958,7 @@ fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; name = "VoicesViewController.m: 47"; rLen = 0; - rLoc = 1137; + rLoc = 1147; rType = 0; vrLen = 512; vrLoc = 943; @@ -5087,12 +5153,6 @@ name = UIImageExtra.h; path = /Users/vittorio/hedgewars/trunk/cocoaTouch/otherSrc/UIImageScale.h; sourceTree = ""; - uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {572, 234}}"; - sepNavSelRange = "{0, 0}"; - sepNavVisRange = "{0, 336}"; - sepNavWindowFrame = "{{577, 245}, {1058, 792}}"; - }; }; 619C58AA116E752A0049FD84 /* UIImageExtra.m */ = { isa = PBXFileReference; @@ -5101,12 +5161,6 @@ name = UIImageExtra.m; path = /Users/vittorio/hedgewars/trunk/cocoaTouch/otherSrc/UIImageScale.m; sourceTree = ""; - uiCtxt = { - sepNavIntBoundsRect = "{{0, 0}, {474, 676}}"; - sepNavSelRange = "{216, 0}"; - sepNavVisRange = "{0, 371}"; - sepNavWindowFrame = "{{577, 245}, {1058, 792}}"; - }; }; 619C58B2116E76080049FD84 /* PBXBookmark */ = { isa = PBXBookmark; @@ -5242,6 +5296,783 @@ vrLen = 779; vrLoc = 123261; }; + 61C3251C1179A300001E70B1 /* openalbridge */ = { + activeExec = 0; + }; + 61C325231179A314001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 6184DEA211795DBD00AF6EFA /* UIImageExtra.m */; + name = "UIImageExtra.m: 9"; + rLen = 0; + rLoc = 145; + rType = 0; + vrLen = 246; + vrLoc = 0; + }; + 61C325241179A314001E70B1 /* PBXBookmark */ = { + isa = PBXBookmark; + fRef = 618BE5911175126900F22556 /* LevelViewController.h */; + }; + 61C325251179A314001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE5911175126900F22556 /* LevelViewController.h */; + name = "LevelViewController.h: 2"; + rLen = 0; + rLoc = 26; + rType = 0; + vrLen = 274; + vrLoc = 0; + }; + 61C325381179A32A001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE5911175126900F22556 /* LevelViewController.h */; + name = "LevelViewController.h: 2"; + rLen = 0; + rLoc = 26; + rType = 0; + vrLen = 274; + vrLoc = 0; + }; + 61C325391179A336001E70B1 /* errlib.c */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {579, 1425}}"; + sepNavSelRange = "{871, 0}"; + sepNavVisRange = "{509, 440}"; + sepNavWindowFrame = "{{153, 250}, {1086, 797}}"; + }; + }; + 61C3253A1179A336001E70B1 /* errlib.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1027, 669}}"; + sepNavSelRange = "{0, 839}"; + sepNavVisRange = "{0, 839}"; + sepNavWindowFrame = "{{130, 271}, {1086, 797}}"; + }; + }; + 61C3253B1179A336001E70B1 /* globals.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {558, 2310}}"; + sepNavSelRange = "{1163, 0}"; + sepNavVisRange = "{977, 202}"; + sepNavWindowFrame = "{{107, 292}, {1086, 797}}"; + }; + }; + 61C3253C1179A336001E70B1 /* loaders.c */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {789, 3840}}"; + sepNavSelRange = "{902, 0}"; + sepNavVisRange = "{828, 595}"; + }; + }; + 61C3253D1179A336001E70B1 /* loaders.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {803, 555}}"; + sepNavSelRange = "{899, 0}"; + sepNavVisRange = "{829, 414}"; + }; + }; + 61C3253E1179A336001E70B1 /* openalbridge.c */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {558, 7830}}"; + sepNavSelRange = "{0, 0}"; + sepNavVisRange = "{69, 615}"; + sepNavWindowFrame = "{{622, 369}, {1086, 797}}"; + }; + }; + 61C325401179A336001E70B1 /* openalbridge.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1027, 720}}"; + sepNavSelRange = "{2053, 0}"; + sepNavVisRange = "{3, 2114}"; + sepNavWindowFrame = "{{622, 369}, {1086, 797}}"; + }; + }; + 61C325411179A336001E70B1 /* wrappers.c */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {1027, 2175}}"; + sepNavSelRange = "{0, 4432}"; + sepNavVisRange = "{0, 1355}"; + sepNavWindowFrame = "{{61, 334}, {1086, 797}}"; + }; + }; + 61C325421179A336001E70B1 /* wrappers.h */ = { + uiCtxt = { + sepNavIntBoundsRect = "{{0, 0}, {558, 630}}"; + sepNavSelRange = "{1077, 0}"; + sepNavVisRange = "{901, 404}"; + sepNavWindowFrame = "{{84, 313}, {1086, 797}}"; + }; + }; + 61C325681179A3A0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE5911175126900F22556 /* LevelViewController.h */; + name = "LevelViewController.h: 2"; + rLen = 0; + rLoc = 26; + rType = 0; + vrLen = 274; + vrLoc = 0; + }; + 61C325691179A3A0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C325401179A336001E70B1 /* openalbridge.h */; + name = "openalbridge.h: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 684; + vrLoc = 0; + }; + 61C3256A1179A3A0001E70B1 /* XCBuildMessageTextBookmark */ = { + isa = PBXTextBookmark; + comments = "Al.h: No such file or directory"; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + fallbackIsa = XCBuildMessageTextBookmark; + rLen = 1; + rLoc = 38; + rType = 1; + }; + 61C3256B1179A3A0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 232; + vrLoc = 997; + }; + 61C325701179A405001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 232; + vrLoc = 997; + }; + 61C3257C1179A4AD001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 285; + vrLoc = 957; + }; + 61C3257D1179A4AD001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253C1179A336001E70B1 /* loaders.c */; + name = "loaders.c: 139"; + rLen = 0; + rLoc = 7404; + rType = 0; + vrLen = 618; + vrLoc = 828; + }; + 61C3257E1179A4AD001E70B1 /* XCBuildMessageTextBookmark */ = { + isa = PBXTextBookmark; + comments = "Vorbis/vorbisfile.h: No such file or directory"; + fRef = 61C3253D1179A336001E70B1 /* loaders.h */; + fallbackIsa = XCBuildMessageTextBookmark; + rLen = 0; + rLoc = 22; + rType = 1; + }; + 61C3257F1179A4AD001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253D1179A336001E70B1 /* loaders.h */; + name = "loaders.h: 24"; + rLen = 0; + rLoc = 899; + rType = 0; + vrLen = 443; + vrLoc = 853; + }; + 61C325891179A593001E70B1 /* PBXBookmark */ = { + isa = PBXBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + }; + 61C325941179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 684; + vrLoc = 0; + }; + 61C325951179A75D001E70B1 /* XCBuildMessageTextBookmark */ = { + isa = PBXTextBookmark; + comments = "Al.h: No such file or directory"; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + fallbackIsa = XCBuildMessageTextBookmark; + rLen = 1; + rLoc = 38; + rType = 1; + }; + 61C325961179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 222; + vrLoc = 977; + }; + 61C325991179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A1117527CD00F22556 /* VoicesViewController.h */; + name = "VoicesViewController.h: 10"; + rLen = 0; + rLoc = 177; + rType = 0; + vrLen = 549; + vrLoc = 0; + }; + 61C3259A1179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 2"; + rLen = 0; + rLoc = 27; + rType = 0; + vrLen = 1099; + vrLoc = 0; + }; + 61C3259B1179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 56"; + rLen = 0; + rLoc = 1348; + rType = 0; + vrLen = 1071; + vrLoc = 0; + }; + 61C3259E1179A75D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 430"; + rLen = 16; + rLoc = 14605; + rType = 0; + vrLen = 1482; + vrLoc = 0; + }; + 61C325AB1179A88A001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 222; + vrLoc = 977; + }; + 61C325AC1179A88A001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 56"; + rLen = 0; + rLoc = 1348; + rType = 0; + vrLen = 1071; + vrLoc = 0; + }; + 61C325AD1179A88A001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 433"; + rLen = 16; + rLoc = 14605; + rType = 0; + vrLen = 1441; + vrLoc = 0; + }; + 61C325B91179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C325421179A336001E70B1 /* wrappers.h */; + name = "wrappers.h: 32"; + rLen = 0; + rLoc = 1077; + rType = 0; + vrLen = 404; + vrLoc = 901; + }; + 61C325BA1179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253D1179A336001E70B1 /* loaders.h */; + name = "loaders.h: 23"; + rLen = 0; + rLoc = 899; + rType = 0; + vrLen = 390; + vrLoc = 853; + }; + 61C325BB1179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253C1179A336001E70B1 /* loaders.c */; + name = "loaders.c: 21"; + rLen = 0; + rLoc = 902; + rType = 0; + vrLen = 595; + vrLoc = 828; + }; + 61C325BC1179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 285; + vrLoc = 957; + }; + 61C325BD1179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C325BE1179A8E0001E70B1 /* vorbisfile.h */; + name = "vorbisfile.h: 75"; + rLen = 0; + rLoc = 2966; + rType = 0; + vrLen = 885; + vrLoc = 2645; + }; + 61C325BE1179A8E0001E70B1 /* vorbisfile.h */ = { + isa = PBXFileReference; + name = vorbisfile.h; + path = "/Users/vittorio/hedgewars/trunk/project_files/HedgewarsMobile/../../../Library/libvorbis-1.3.1/include/vorbis/vorbisfile.h"; + sourceTree = ""; + }; + 61C325BF1179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 140"; + rLen = 0; + rLoc = 4909; + rType = 0; + vrLen = 580; + vrLoc = 4373; + }; + 61C325C01179A8E0001E70B1 /* XCBuildMessageTextBookmark */ = { + isa = PBXTextBookmark; + comments = "Format not a string literal and no format arguments"; + fRef = 61C325391179A336001E70B1 /* errlib.c */; + fallbackIsa = XCBuildMessageTextBookmark; + rLen = 1; + rLoc = 36; + rType = 1; + }; + 61C325C11179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C325391179A336001E70B1 /* errlib.c */; + name = "errlib.c: 41"; + rLen = 0; + rLoc = 871; + rType = 0; + vrLen = 440; + vrLoc = 509; + }; + 61C325C21179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 222; + vrLoc = 977; + }; + 61C325C31179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 56"; + rLen = 0; + rLoc = 1348; + rType = 0; + vrLen = 1071; + vrLoc = 0; + }; + 61C325C41179A8E0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 433"; + rLen = 16; + rLoc = 14605; + rType = 0; + vrLen = 1441; + vrLoc = 0; + }; + 61C325C91179A8F9001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 202; + vrLoc = 977; + }; + 61C325CA1179A8F9001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 56"; + rLen = 0; + rLoc = 1348; + rType = 0; + vrLen = 1067; + vrLoc = 0; + }; + 61C325CB1179A8F9001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 433"; + rLen = 16; + rLoc = 14605; + rType = 0; + vrLen = 1438; + vrLoc = 3; + }; + 61C325CF1179A913001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 140"; + rLen = 0; + rLoc = 4909; + rType = 0; + vrLen = 580; + vrLoc = 4373; + }; + 61C325D01179A913001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 140"; + rLen = 0; + rLoc = 4909; + rType = 0; + vrLen = 564; + vrLoc = 4373; + }; + 61C325D41179A93D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 202; + vrLoc = 977; + }; + 61C325D51179A93D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A1117527CD00F22556 /* VoicesViewController.h */; + name = "VoicesViewController.h: 10"; + rLen = 0; + rLoc = 177; + rType = 0; + vrLen = 549; + vrLoc = 0; + }; + 61C325D61179A93D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 143"; + rLen = 0; + rLoc = 4155; + rType = 0; + vrLen = 1674; + vrLoc = 3466; + }; + 61C325D71179A93D001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 143"; + rLen = 0; + rLoc = 4155; + rType = 0; + vrLen = 1674; + vrLoc = 3466; + }; + 61C325DA1179A97D001E70B1 /* PBXBookmark */ = { + isa = PBXBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + }; + 61C325DD1179A993001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253B1179A336001E70B1 /* globals.h */; + name = "globals.h: 39"; + rLen = 0; + rLoc = 1163; + rType = 0; + vrLen = 202; + vrLoc = 977; + }; + 61C325DE1179A993001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325DF1179A993001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325E21179A993001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 144"; + rLen = 0; + rLoc = 5079; + rType = 0; + vrLen = 1545; + vrLoc = 4313; + }; + 61C325E31179A993001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 143"; + rLen = 0; + rLoc = 4155; + rType = 0; + vrLen = 1674; + vrLoc = 3466; + }; + 61C325E51179AAD5001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 755; + vrLoc = 69; + }; + 61C325E61179AAD5001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 65"; + rLen = 0; + rLoc = 2088; + rType = 0; + vrLen = 1308; + vrLoc = 1136; + }; + 61C325E71179AAD5001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 143"; + rLen = 0; + rLoc = 4155; + rType = 0; + vrLen = 1721; + vrLoc = 3466; + }; + 61C325EA1179AB00001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325EB1179AB00001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 97"; + rLen = 0; + rLoc = 3235; + rType = 0; + vrLen = 1655; + vrLoc = 2170; + }; + 61C325EC1179AB00001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 143"; + rLen = 0; + rLoc = 4155; + rType = 0; + vrLen = 1674; + vrLoc = 3466; + }; + 61C325F01179ABBC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325F11179ABBC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 178"; + rLen = 0; + rLoc = 5543; + rType = 0; + vrLen = 1549; + vrLoc = 4284; + }; + 61C325F21179ABBC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 517"; + rLen = 0; + rLoc = 17280; + rType = 0; + vrLen = 1274; + vrLoc = 16306; + }; + 61C325F61179ABFC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325F71179ABFC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 29"; + rLen = 0; + rLoc = 633; + rType = 0; + vrLen = 1097; + vrLoc = 244; + }; + 61C325F81179ABFC001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 517"; + rLen = 0; + rLoc = 17280; + rType = 0; + vrLen = 1274; + vrLoc = 16306; + }; + 61C325FC1179ADCA001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C325FD1179ADCA001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 515"; + rLen = 0; + rLoc = 17280; + rType = 0; + vrLen = 1265; + vrLoc = 16270; + }; + 61C325FE1179ADCA001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 29"; + rLen = 0; + rLoc = 633; + rType = 0; + vrLen = 1013; + vrLoc = 336; + }; + 61C326001179ADCF001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C326011179ADCF001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 514"; + rLen = 0; + rLoc = 17280; + rType = 0; + vrLen = 1171; + vrLoc = 16251; + }; + 61C326021179ADCF001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 29"; + rLen = 0; + rLoc = 633; + rType = 0; + vrLen = 1013; + vrLoc = 336; + }; + 61C326031179AE31001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 755; + vrLoc = 69; + }; + 61C326041179AE31001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 170"; + rLen = 0; + rLoc = 5414; + rType = 0; + vrLen = 1759; + vrLoc = 3658; + }; + 61C326071179AEE0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 61C3253E1179A336001E70B1 /* openalbridge.c */; + name = "openalbridge.c: 1"; + rLen = 0; + rLoc = 0; + rType = 0; + vrLen = 615; + vrLoc = 69; + }; + 61C326081179AEE0001E70B1 /* PBXTextBookmark */ = { + isa = PBXTextBookmark; + fRef = 618BE6A2117527CD00F22556 /* VoicesViewController.m */; + name = "VoicesViewController.m: 29"; + rLen = 0; + rLoc = 630; + rType = 0; + vrLen = 1063; + vrLoc = 3; + }; 61CCBE60116135FF00833FE8 /* PBXTextBookmark */ = { isa = PBXTextBookmark; fRef = 61798800114AA34C00BA94A9 /* uLandGraphics.pas */; diff -r ac5d14a35482 -r a767dd3786b5 project_files/hedgewars.pro --- a/project_files/hedgewars.pro Sat Apr 17 04:59:10 2010 +0000 +++ b/project_files/hedgewars.pro Sat Apr 17 08:30:34 2010 +0000 @@ -59,7 +59,7 @@ ../QTfrontend/achievements.cpp win32 { -SOURCES += ../QTfrontend/xfire.cpp + SOURCES += ../QTfrontend/xfire.cpp } TRANSLATIONS += ../share/hedgewars/Data/Locale/hedgewars_bg.ts @@ -87,17 +87,18 @@ !macx { LIBS += -lSDL -lSDL_Mixer } else { - QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.4 - QMAKE_MAC_SDK=/Developer/SDKs/MacOSX10.4u.sdk + QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.6 + QMAKE_MAC_SDK=/Developer/SDKs/MacOSX10.6.sdk - OBJECTIVE_SOURCES = ../QTfrontend/*.m ../QTfrontend/*.mm - SOURCES += ../QTfrontend/AutoUpdater.cpp ../QTfrontend/InstallController.cpp + OBJECTIVE_SOURCES += ../QTfrontend/*.m ../QTfrontend/*.mm + SOURCES += ../QTfrontend/AutoUpdater.cpp ../QTfrontend/InstallController.cpp \ + ../../build/QTfrontend/hwconsts.cpp HEADERS += ../QTfrontend/M3InstallController.h ../QTfrontend/M3Panel.h \ ../QTfrontend/NSWorkspace_RBAdditions.h ../QTfrontend/AutoUpdater.h \ ../QTfrontend/CocoaInitializer.h ../QTfrontend/InstallController.h \ ../QTfrontend/SparkleAutoUpdater.h - LIBS += -framework IOKit -framework SDL -framework SDL_Mixer -framework Sparkle -DSPARKLE_ENABLED + LIBS += -lobjc -framework AppKit -framework IOKit -framework Foundation -framework SDL -framework SDL_Mixer -framework Sparkle -DSPARKLE_ENABLED INCLUDEPATH += /Library/Frameworks/SDL.framework/Headers /Library/Frameworks/SDL_Mixer.framework/Headers CONFIG += warn_on x86