mirror of
https://github.com/id-Software/DOOM-iOS.git
synced 2026-03-20 00:49:34 +01:00
Source release for DOOM Classic for iOS version 2.1
This commit is contained in:
Travis Bradshaw
507
code/iphone/.svn/text-base/BackgroundMusic.cpp.svn-base
Normal file
507
code/iphone/.svn/text-base/BackgroundMusic.cpp.svn-base
Normal file
@@ -0,0 +1,507 @@
|
||||
/*
|
||||
* BackgroundMusic.cpp
|
||||
* doom
|
||||
*
|
||||
* Created by John Carmack on 5/15/09.
|
||||
* Copyright 2009 Id Software. All rights reserved.
|
||||
*
|
||||
*/
|
||||
|
||||
//==================================================================================================
|
||||
// Includes
|
||||
//==================================================================================================
|
||||
|
||||
// System Includes
|
||||
#include <AudioToolbox/AudioToolbox.h>
|
||||
#include <CoreFoundation/CFURL.h>
|
||||
#include <OpenAL/al.h>
|
||||
#include <OpenAL/alc.h>
|
||||
#include <map>
|
||||
#include <vector>
|
||||
#include <pthread.h>
|
||||
#include <mach/mach.h>
|
||||
#include <string>
|
||||
|
||||
extern "C" {
|
||||
#include "doomiphone.h"
|
||||
}
|
||||
|
||||
enum {
|
||||
kSoundEngineErrUnitialized = 1,
|
||||
kSoundEngineErrInvalidID = 2,
|
||||
kSoundEngineErrFileNotFound = 3,
|
||||
kSoundEngineErrInvalidFileFormat = 4,
|
||||
kSoundEngineErrDeviceNotFound = 5
|
||||
};
|
||||
|
||||
|
||||
#define AssertNoError(inMessage, inHandler) \
|
||||
if(result != noErr) \
|
||||
{ \
|
||||
printf("%s: %d\n", inMessage, (int)result); \
|
||||
goto inHandler; \
|
||||
}
|
||||
|
||||
|
||||
#define kNumberBuffers 3
|
||||
|
||||
|
||||
static Float32 gMasterVolumeGain = 0.5f;
|
||||
|
||||
|
||||
//==================================================================================================
|
||||
// Helper functions
|
||||
//==================================================================================================
|
||||
|
||||
OSStatus LoadFileDataInfo(const char *inFilePath, AudioFileID &outAFID, AudioStreamBasicDescription &outFormat, UInt64 &outDataSize)
|
||||
{
|
||||
UInt32 thePropSize;
|
||||
|
||||
CFURLRef theURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8*)inFilePath, strlen(inFilePath), false);
|
||||
if (theURL == NULL)
|
||||
return kSoundEngineErrFileNotFound;
|
||||
|
||||
OSStatus result = AudioFileOpenURL(theURL, kAudioFileReadPermission, 0, &outAFID);
|
||||
CFRelease(theURL);
|
||||
AssertNoError("Error opening file", end);
|
||||
|
||||
thePropSize = sizeof(outFormat);
|
||||
result = AudioFileGetProperty(outAFID, kAudioFilePropertyDataFormat, &thePropSize, &outFormat);
|
||||
AssertNoError("Error getting file format", end);
|
||||
|
||||
thePropSize = sizeof(UInt64);
|
||||
result = AudioFileGetProperty(outAFID, kAudioFilePropertyAudioDataByteCount, &thePropSize, &outDataSize);
|
||||
AssertNoError("Error getting file data size", end);
|
||||
|
||||
end:
|
||||
return result;
|
||||
}
|
||||
|
||||
void CalculateBytesForTime (AudioStreamBasicDescription & inDesc, UInt32 inMaxPacketSize, Float64 inSeconds, UInt32 *outBufferSize, UInt32 *outNumPackets)
|
||||
{
|
||||
static const UInt32 maxBufferSize = 0x10000; // limit size to 64K
|
||||
static const UInt32 minBufferSize = 0x4000; // limit size to 16K
|
||||
|
||||
if (inDesc.mFramesPerPacket) {
|
||||
Float64 numPacketsForTime = inDesc.mSampleRate / inDesc.mFramesPerPacket * inSeconds;
|
||||
*outBufferSize = (long unsigned int)numPacketsForTime * inMaxPacketSize;
|
||||
} else {
|
||||
// if frames per packet is zero, then the codec has no predictable packet == time
|
||||
// so we can't tailor this (we don't know how many Packets represent a time period
|
||||
// we'll just return a default buffer size
|
||||
*outBufferSize = maxBufferSize > inMaxPacketSize ? maxBufferSize : inMaxPacketSize;
|
||||
}
|
||||
|
||||
// we're going to limit our size to our default
|
||||
if (*outBufferSize > maxBufferSize && *outBufferSize > inMaxPacketSize)
|
||||
*outBufferSize = maxBufferSize;
|
||||
else {
|
||||
// also make sure we're not too small - we don't want to go the disk for too small chunks
|
||||
if (*outBufferSize < minBufferSize)
|
||||
*outBufferSize = minBufferSize;
|
||||
}
|
||||
*outNumPackets = *outBufferSize / inMaxPacketSize;
|
||||
}
|
||||
|
||||
static Boolean MatchFormatFlags(const AudioStreamBasicDescription& x, const AudioStreamBasicDescription& y)
|
||||
{
|
||||
UInt32 xFlags = x.mFormatFlags;
|
||||
UInt32 yFlags = y.mFormatFlags;
|
||||
|
||||
// match wildcards
|
||||
if (x.mFormatID == 0 || y.mFormatID == 0 || xFlags == 0 || yFlags == 0)
|
||||
return true;
|
||||
|
||||
if (x.mFormatID == kAudioFormatLinearPCM)
|
||||
{
|
||||
// knock off the all clear flag
|
||||
xFlags = xFlags & ~kAudioFormatFlagsAreAllClear;
|
||||
yFlags = yFlags & ~kAudioFormatFlagsAreAllClear;
|
||||
|
||||
// if both kAudioFormatFlagIsPacked bits are set, then we don't care about the kAudioFormatFlagIsAlignedHigh bit.
|
||||
if (xFlags & yFlags & kAudioFormatFlagIsPacked) {
|
||||
xFlags = xFlags & ~kAudioFormatFlagIsAlignedHigh;
|
||||
yFlags = yFlags & ~kAudioFormatFlagIsAlignedHigh;
|
||||
}
|
||||
|
||||
// if both kAudioFormatFlagIsFloat bits are set, then we don't care about the kAudioFormatFlagIsSignedInteger bit.
|
||||
if (xFlags & yFlags & kAudioFormatFlagIsFloat) {
|
||||
xFlags = xFlags & ~kAudioFormatFlagIsSignedInteger;
|
||||
yFlags = yFlags & ~kAudioFormatFlagIsSignedInteger;
|
||||
}
|
||||
|
||||
// if the bit depth is 8 bits or less and the format is packed, we don't care about endianness
|
||||
if((x.mBitsPerChannel <= 8) && ((xFlags & kAudioFormatFlagIsPacked) == kAudioFormatFlagIsPacked))
|
||||
{
|
||||
xFlags = xFlags & ~kAudioFormatFlagIsBigEndian;
|
||||
}
|
||||
if((y.mBitsPerChannel <= 8) && ((yFlags & kAudioFormatFlagIsPacked) == kAudioFormatFlagIsPacked))
|
||||
{
|
||||
yFlags = yFlags & ~kAudioFormatFlagIsBigEndian;
|
||||
}
|
||||
|
||||
// if the number of channels is 0 or 1, we don't care about non-interleavedness
|
||||
if (x.mChannelsPerFrame <= 1 && y.mChannelsPerFrame <= 1) {
|
||||
xFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
|
||||
yFlags &= ~kLinearPCMFormatFlagIsNonInterleaved;
|
||||
}
|
||||
}
|
||||
return xFlags == yFlags;
|
||||
}
|
||||
|
||||
Boolean FormatIsEqual(AudioStreamBasicDescription x, AudioStreamBasicDescription y)
|
||||
{
|
||||
// the semantics for equality are:
|
||||
// 1) Values must match exactly
|
||||
// 2) wildcard's are ignored in the comparison
|
||||
|
||||
#define MATCH(name) ((x.name) == 0 || (y.name) == 0 || (x.name) == (y.name))
|
||||
|
||||
return
|
||||
((x.mSampleRate==0.) || (y.mSampleRate==0.) || (x.mSampleRate==y.mSampleRate))
|
||||
&& MATCH(mFormatID)
|
||||
&& MatchFormatFlags(x, y)
|
||||
&& MATCH(mBytesPerPacket)
|
||||
&& MATCH(mFramesPerPacket)
|
||||
&& MATCH(mBytesPerFrame)
|
||||
&& MATCH(mChannelsPerFrame)
|
||||
&& MATCH(mBitsPerChannel) ;
|
||||
}
|
||||
|
||||
#pragma mark ***** BackgroundTrackMgr *****
|
||||
//==================================================================================================
|
||||
// BackgroundTrackMgr class
|
||||
//==================================================================================================
|
||||
typedef struct BG_FileInfo {
|
||||
std::string mFilePath;
|
||||
AudioFileID mAFID;
|
||||
AudioStreamBasicDescription mFileFormat;
|
||||
UInt64 mFileDataSize;
|
||||
//UInt64 mFileNumPackets; // this is only used if loading file to memory
|
||||
Boolean mLoadAtOnce;
|
||||
Boolean mFileDataInQueue;
|
||||
} BackgroundMusicFileInfo;
|
||||
|
||||
class BackgroundTrackMgr
|
||||
{
|
||||
public:
|
||||
BackgroundTrackMgr();
|
||||
~BackgroundTrackMgr();
|
||||
|
||||
void Teardown();
|
||||
|
||||
static void QueueCallback( void * inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer);
|
||||
|
||||
OSStatus SetupQueue(BG_FileInfo *inFileInfo);
|
||||
OSStatus SetupBuffers(BG_FileInfo *inFileInfo);
|
||||
OSStatus LoadTrack(const char* inFilePath, Boolean inAddToQueue, Boolean inLoadAtOnce);
|
||||
|
||||
OSStatus SetVolume(Float32 inVolume);
|
||||
Float32 GetVolume() const;
|
||||
|
||||
OSStatus Start();
|
||||
OSStatus Stop(Boolean inStopAtEnd);
|
||||
|
||||
AudioQueueRef mQueue;
|
||||
AudioQueueBufferRef mBuffers[kNumberBuffers];
|
||||
UInt32 mBufferByteSize;
|
||||
SInt64 mCurrentPacket;
|
||||
UInt32 mNumPacketsToRead;
|
||||
Float32 mVolume;
|
||||
AudioStreamPacketDescription * mPacketDescs;
|
||||
static BG_FileInfo * CurFileInfo;
|
||||
Boolean mStopAtEnd;
|
||||
};
|
||||
|
||||
BG_FileInfo *BackgroundTrackMgr::CurFileInfo;
|
||||
|
||||
|
||||
BackgroundTrackMgr::BackgroundTrackMgr()
|
||||
: mQueue(0),
|
||||
mBufferByteSize(0),
|
||||
mCurrentPacket(0),
|
||||
mNumPacketsToRead(0),
|
||||
mVolume(1.0f),
|
||||
mPacketDescs(NULL),
|
||||
mStopAtEnd(false)
|
||||
{ }
|
||||
|
||||
BackgroundTrackMgr::~BackgroundTrackMgr() {
|
||||
Teardown();
|
||||
}
|
||||
|
||||
void BackgroundTrackMgr::Teardown() {
|
||||
if (mQueue) {
|
||||
AudioQueueDispose(mQueue, true);
|
||||
mQueue = NULL;
|
||||
}
|
||||
if ( CurFileInfo ) {
|
||||
AudioFileClose( CurFileInfo->mAFID);
|
||||
delete CurFileInfo;
|
||||
CurFileInfo = NULL;
|
||||
}
|
||||
if (mPacketDescs) {
|
||||
delete[] mPacketDescs;
|
||||
mPacketDescs = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void BackgroundTrackMgr::QueueCallback( void * inUserData, AudioQueueRef inAQ, AudioQueueBufferRef inCompleteAQBuffer ) {
|
||||
// dispose of the buffer if no longer in use
|
||||
OSStatus result = noErr;
|
||||
BackgroundTrackMgr *THIS = (BackgroundTrackMgr*)inUserData;
|
||||
UInt32 nPackets = 0;
|
||||
// loop the current buffer if the following:
|
||||
// 1. file was loaded into the buffer previously
|
||||
// 2. only one file in the queue
|
||||
// 3. we have not been told to stop at playlist completion
|
||||
if ((CurFileInfo->mFileDataInQueue) && (!THIS->mStopAtEnd)) {
|
||||
nPackets = THIS->mNumPacketsToRead;
|
||||
} else {
|
||||
UInt32 numBytes;
|
||||
while (nPackets == 0) {
|
||||
// if loadAtOnce, get all packets in the file, otherwise ~.5 seconds of data
|
||||
nPackets = THIS->mNumPacketsToRead;
|
||||
result = AudioFileReadPackets(CurFileInfo->mAFID, false, &numBytes, THIS->mPacketDescs, THIS->mCurrentPacket, &nPackets,
|
||||
inCompleteAQBuffer->mAudioData);
|
||||
AssertNoError("Error reading file data", end);
|
||||
|
||||
inCompleteAQBuffer->mAudioDataByteSize = numBytes;
|
||||
|
||||
if (nPackets == 0) { // no packets were read, this file has ended.
|
||||
if (CurFileInfo->mLoadAtOnce) {
|
||||
CurFileInfo->mFileDataInQueue = true;
|
||||
}
|
||||
|
||||
THIS->mCurrentPacket = 0;
|
||||
|
||||
// we have gone through the playlist. if mStopAtEnd, stop the queue here
|
||||
if ( THIS->mStopAtEnd ) {
|
||||
result = AudioQueueStop(inAQ, false);
|
||||
AssertNoError("Error stopping queue", end);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result = AudioQueueEnqueueBuffer(inAQ, inCompleteAQBuffer, (THIS->mPacketDescs ? nPackets : 0), THIS->mPacketDescs);
|
||||
if(result != noErr) {
|
||||
result = AudioQueueFreeBuffer(inAQ, inCompleteAQBuffer);
|
||||
AssertNoError("Error freeing buffers that didn't enqueue", end);
|
||||
}
|
||||
AssertNoError("Error enqueuing new buffer", end);
|
||||
if (CurFileInfo->mLoadAtOnce) {
|
||||
CurFileInfo->mFileDataInQueue = true;
|
||||
}
|
||||
|
||||
THIS->mCurrentPacket += nPackets;
|
||||
|
||||
end:
|
||||
return;
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::SetupQueue(BG_FileInfo *inFileInfo) {
|
||||
UInt32 size = 0;
|
||||
OSStatus result = AudioQueueNewOutput(&inFileInfo->mFileFormat, QueueCallback, this,
|
||||
CFRunLoopGetMain() /* CFRunLoopGetCurrent() */, kCFRunLoopCommonModes, 0, &mQueue);
|
||||
AssertNoError("Error creating queue", end);
|
||||
#if 0
|
||||
// (2) If the file has a cookie, we should get it and set it on the AQ
|
||||
size = sizeof(UInt32);
|
||||
result = AudioFileGetPropertyInfo (inFileInfo->mAFID, kAudioFilePropertyMagicCookieData, &size, NULL);
|
||||
|
||||
if (!result && size) {
|
||||
char* cookie = new char [size];
|
||||
result = AudioFileGetProperty (inFileInfo->mAFID, kAudioFilePropertyMagicCookieData, &size, cookie);
|
||||
AssertNoError("Error getting magic cookie", end);
|
||||
result = AudioQueueSetProperty(mQueue, kAudioQueueProperty_MagicCookie, cookie, size);
|
||||
delete [] cookie;
|
||||
AssertNoError("Error setting magic cookie", end);
|
||||
}
|
||||
#endif
|
||||
// channel layout
|
||||
OSStatus err = AudioFileGetPropertyInfo(inFileInfo->mAFID, kAudioFilePropertyChannelLayout, &size, NULL);
|
||||
if (err == noErr && size > 0) {
|
||||
AudioChannelLayout *acl = (AudioChannelLayout *)malloc(size);
|
||||
result = AudioFileGetProperty(inFileInfo->mAFID, kAudioFilePropertyChannelLayout, &size, acl);
|
||||
AssertNoError("Error getting channel layout from file", end);
|
||||
result = AudioQueueSetProperty(mQueue, kAudioQueueProperty_ChannelLayout, acl, size);
|
||||
free(acl);
|
||||
AssertNoError("Error setting channel layout on queue", end);
|
||||
}
|
||||
|
||||
// volume
|
||||
result = SetVolume(mVolume);
|
||||
|
||||
end:
|
||||
return result;
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::SetupBuffers(BG_FileInfo *inFileInfo) {
|
||||
int numBuffersToQueue = kNumberBuffers;
|
||||
UInt32 maxPacketSize;
|
||||
UInt32 size = sizeof(maxPacketSize);
|
||||
// we need to calculate how many packets we read at a time, and how big a buffer we need
|
||||
// we base this on the size of the packets in the file and an approximate duration for each buffer
|
||||
|
||||
// first check to see what the max size of a packet is - if it is bigger
|
||||
// than our allocation default size, that needs to become larger
|
||||
OSStatus result = AudioFileGetProperty(inFileInfo->mAFID, kAudioFilePropertyPacketSizeUpperBound, &size, &maxPacketSize);
|
||||
AssertNoError("Error getting packet upper bound size", end);
|
||||
bool isFormatVBR = (inFileInfo->mFileFormat.mBytesPerPacket == 0 || inFileInfo->mFileFormat.mFramesPerPacket == 0);
|
||||
|
||||
CalculateBytesForTime(inFileInfo->mFileFormat, maxPacketSize, 0.5/*seconds*/, &mBufferByteSize, &mNumPacketsToRead);
|
||||
|
||||
// if the file is smaller than the capacity of all the buffer queues, always load it at once
|
||||
if ((mBufferByteSize * numBuffersToQueue) > inFileInfo->mFileDataSize) {
|
||||
inFileInfo->mLoadAtOnce = true;
|
||||
}
|
||||
|
||||
if (inFileInfo->mLoadAtOnce) {
|
||||
UInt64 theFileNumPackets;
|
||||
size = sizeof(UInt64);
|
||||
result = AudioFileGetProperty(inFileInfo->mAFID, kAudioFilePropertyAudioDataPacketCount, &size, &theFileNumPackets);
|
||||
AssertNoError("Error getting packet count for file", end);
|
||||
|
||||
mNumPacketsToRead = (UInt32)theFileNumPackets;
|
||||
mBufferByteSize = (UInt32)inFileInfo->mFileDataSize;
|
||||
numBuffersToQueue = 1;
|
||||
} else {
|
||||
mNumPacketsToRead = mBufferByteSize / maxPacketSize;
|
||||
}
|
||||
|
||||
if (isFormatVBR) {
|
||||
mPacketDescs = new AudioStreamPacketDescription [mNumPacketsToRead];
|
||||
} else {
|
||||
mPacketDescs = NULL; // we don't provide packet descriptions for constant bit rate formats (like linear PCM)
|
||||
}
|
||||
|
||||
// allocate the queue's buffers
|
||||
for (int i = 0; i < numBuffersToQueue; ++i) {
|
||||
result = AudioQueueAllocateBuffer(mQueue, mBufferByteSize, &mBuffers[i]);
|
||||
AssertNoError("Error allocating buffer for queue", end);
|
||||
QueueCallback (this, mQueue, mBuffers[i]);
|
||||
if (inFileInfo->mLoadAtOnce) {
|
||||
inFileInfo->mFileDataInQueue = true;
|
||||
}
|
||||
}
|
||||
|
||||
end:
|
||||
return result;
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::LoadTrack(const char* inFilePath, Boolean inAddToQueue, Boolean inLoadAtOnce) {
|
||||
// OSStatus result = LoadFileDataInfo(CurFileInfo->mFilePath.c_str(), CurFileInfo->mAFID, CurFileInfo->mFileFormat, CurFileInfo->mFileDataSize);
|
||||
// AssertNoError("Error getting file data info", fail);
|
||||
OSStatus result;
|
||||
UInt32 thePropSize;
|
||||
|
||||
CFURLRef theURL = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault, (UInt8*)inFilePath, strlen(inFilePath), false);
|
||||
if (theURL == NULL)
|
||||
result = kSoundEngineErrFileNotFound;
|
||||
else
|
||||
result = 0;
|
||||
AssertNoError("Error opening URL", fail);
|
||||
|
||||
CurFileInfo = new BG_FileInfo;
|
||||
CurFileInfo->mFilePath = inFilePath;
|
||||
|
||||
result = AudioFileOpenURL(theURL, kAudioFileReadPermission, 0, &CurFileInfo->mAFID);
|
||||
CFRelease(theURL);
|
||||
AssertNoError("Error opening file", fail);
|
||||
|
||||
thePropSize = sizeof(CurFileInfo->mFileFormat);
|
||||
result = AudioFileGetProperty(CurFileInfo->mAFID, kAudioFilePropertyDataFormat, &thePropSize, &CurFileInfo->mFileFormat);
|
||||
AssertNoError("Error getting file format", fail);
|
||||
|
||||
thePropSize = sizeof(UInt64);
|
||||
result = AudioFileGetProperty(CurFileInfo->mAFID, kAudioFilePropertyAudioDataByteCount, &thePropSize, &CurFileInfo->mFileDataSize);
|
||||
AssertNoError("Error getting file data size", fail);
|
||||
|
||||
CurFileInfo->mLoadAtOnce = inLoadAtOnce;
|
||||
CurFileInfo->mFileDataInQueue = false;
|
||||
|
||||
result = SetupQueue(CurFileInfo);
|
||||
AssertNoError("Error setting up queue", fail);
|
||||
|
||||
result = SetupBuffers(CurFileInfo);
|
||||
AssertNoError("Error setting up queue buffers", fail);
|
||||
|
||||
return result;
|
||||
|
||||
fail:
|
||||
if (CurFileInfo) {
|
||||
delete CurFileInfo;
|
||||
CurFileInfo = NULL;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::SetVolume(Float32 inVolume) {
|
||||
mVolume = inVolume;
|
||||
return AudioQueueSetParameter(mQueue, kAudioQueueParam_Volume, mVolume * gMasterVolumeGain);
|
||||
}
|
||||
|
||||
Float32 BackgroundTrackMgr::GetVolume() const {
|
||||
return mVolume;
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::Start() {
|
||||
OSStatus result = AudioQueuePrime(mQueue, 1, NULL);
|
||||
if (result) {
|
||||
printf("BackgroundTrackMgr: Error priming queue: %d\n", (int)result);
|
||||
return result;
|
||||
}
|
||||
return AudioQueueStart(mQueue, NULL);
|
||||
}
|
||||
|
||||
OSStatus BackgroundTrackMgr::Stop(Boolean inStopAtEnd) {
|
||||
if (inStopAtEnd) {
|
||||
mStopAtEnd = true;
|
||||
return noErr;
|
||||
} else {
|
||||
return AudioQueueStop(mQueue, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static BackgroundTrackMgr sBackgroundTrackMgr;
|
||||
|
||||
static char currentMusicName[1024];
|
||||
void iphoneStopMusic() {
|
||||
sBackgroundTrackMgr.Teardown();
|
||||
}
|
||||
|
||||
void iphoneStartMusic() {
|
||||
if ( music->value == 0 ) {
|
||||
// music is disabled
|
||||
return;
|
||||
}
|
||||
char fullName[1024];
|
||||
sprintf( fullName, "%s/base/music/d_%s.mp3", SysIphoneGetAppDir(), currentMusicName );
|
||||
|
||||
printf( "Starting music '%s'\n", fullName );
|
||||
|
||||
iphoneStopMusic();
|
||||
sBackgroundTrackMgr.LoadTrack( fullName, false, true);
|
||||
sBackgroundTrackMgr.Start();
|
||||
|
||||
if ( !strcmp( currentMusicName, "intro" ) ) {
|
||||
// stop the intro music at end, don't loop
|
||||
sBackgroundTrackMgr.mStopAtEnd = true;
|
||||
} else {
|
||||
sBackgroundTrackMgr.mStopAtEnd = false;
|
||||
}
|
||||
}
|
||||
|
||||
void iphonePlayMusic( const char *name ) {
|
||||
strcpy( currentMusicName, name );
|
||||
|
||||
iphoneStartMusic();
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user