FMODEngine::FMODEngine(int nSampleRate, int nChannels, int nFlags)
{
FSOUND_Init(nSampleRate,nChannels,nFlags);
FSOUND_SetBufferSize( 500 );
m_OpenMode = OpenMode_Default;
}
void InitSound( void )
{
#ifndef UseSDLMixer
if (!FSOUND_Init(44100, 64, FSOUND_INIT_USEDEFAULTMIDISYNTH))
{
musicOn = soundOn = false;
return;
}
#endif
for( int index=0; index<kNumSounds; index++ )
{
#ifdef UseSDLMixer
sound[index] = Mix_LoadWAV( QuickResourceName("snd", index+128, ".wav"));
#else
for( index=0; index<kNumSounds; index++ )
{
sound[index] = FSOUND_Sample_Load( FSOUND_UNMANAGED, QuickResourceName( "snd", index+128, ".wav" ), FSOUND_NORMAL | FSOUND_LOOP_OFF | FSOUND_2D, 0, 0 );
if( sound[index] == NULL )
{
Error( "InitSound: files are missing" );
}
}
#endif
}
}
//================================================================================================//
void Engine::InitFmod()
{
gLog.OutPut("\n[Initializing FMOD]\n");
FSOUND_Init(44100, 32, 0);
gLog.OutPut("Complete...\n\n");
}
/*
-------------------- Initialization functions for the SoundManager2 class --------------------
*/
bool SoundManager2::initialize( bool debug_flag ){
setDebug( debug_flag );
activate();
setMusicVolume(255);
setSoundEffectVolume(255);
setMusicChannel(1);
setSwapMusicChannel(2);
setInitialSoundEffectChannel(3);
setSoundEffectChannel(getInitialSoundEffectChannel());
setMaxChannels(64);
bool initialized = FSOUND_Init (44100, getMaxChannels(), 0);
if(isDebug()){
printf("SoundManager Initialization (debug: %i):\n", isDebug());
printf("\tActive: %i\n", isActive());
printf("\tMusic Volume: %i\n", getMusicVolume());
printf("\tSound Effect Volume: %i\n", getSoundEffectVolume());
printf("\tSound Effect Channel: %i\n", getSoundEffectChannel());
printf("\tMusic Channel: %i\n", getMusicChannel());
printf("\tSwap Music Channel: %i\n", getSwapMusicChannel());
printf("\tInitial Sound Effect Channel: %i\n", getInitialSoundEffectChannel());
printf("\tMusic Channel: %i\n", getMusicChannel());
}
return initialized;
}
SoundManager::SoundManager()
{
const char FileAmbiente[] = "resources/sound/wavs/pacman.ogg\0";
const char FilePaso[] = "resources/sound/wavs/paso.wav\0";
const char FileBoing[] = "resources/sound/wavs/boing.ogg\0";
const char FilePD[] = "resources/sound/wavs/playerdead.ogg\0";
const char FileBola[] = "resources/sound/wavs/bola.ogg\0";
if( !FSOUND_Init(44000, 8, 0) )
{
Log::Instance().Write("Error inicializando sonido: %d\n", FSOUND_GetError());
}
Ambiente = FSOUND_Sample_Load(FSOUND_UNMANAGED, FileAmbiente, FSOUND_LOOP_NORMAL | FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if( !Ambiente )
Log::Instance().Write("Error %d cargando fichero de sonido %s", FSOUND_GetError(), FileAmbiente);
Paso = FSOUND_Sample_Load(FSOUND_UNMANAGED, FilePaso, FSOUND_LOOP_OFF | FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if( !Paso )
Log::Instance().Write("Error %d cargando fichero de sonido %s", FSOUND_GetError(), FilePaso);
Boing = FSOUND_Sample_Load(FSOUND_UNMANAGED, FileBoing, FSOUND_LOOP_OFF | FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if( !Boing )
Log::Instance().Write("Error %d cargando fichero de sonido %s", FSOUND_GetError(), FileBoing);
PlayerDead = FSOUND_Sample_Load(FSOUND_UNMANAGED, FilePD, FSOUND_LOOP_OFF | FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if( !PlayerDead )
Log::Instance().Write("Error %d cargando fichero de sonido %s", FSOUND_GetError(), FilePD);
Bola = FSOUND_Sample_Load(FSOUND_UNMANAGED, FileBola, FSOUND_LOOP_OFF | FSOUND_NORMAL | FSOUND_HW2D, 0, 0);
if( !Bola )
Log::Instance().Write("Error %d cargando fichero de sonido %s", FSOUND_GetError(), FileBola);
// FSOUND_PlaySound(FSOUND_FREE, Ambiente);
}
//===========================================================================
// DM_FModInit
//===========================================================================
int DM_FModInit(void)
{
if(inited)
return true;
if(FSOUND_GetVersion() < FMOD_VERSION)
{
Con_Message
("DM_FModInit: You are using the wrong version of FMOD.DLL!\n"
" You should be using version %.02f.\n", FMOD_VERSION);
return false;
}
if(!FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND))
{
Con_Message("DM_FModInit: Can't use DirectSound.\n");
if(!FSOUND_SetOutput(FSOUND_OUTPUT_WINMM))
{
Con_Message("DM_FModInit: Can't use WINMM!! Aborting...\n");
return false;
}
}
if(!FSOUND_Init(44100, 16, 0))
{
Con_Message("DM_FModInit: Init failed. (%s)\n",
FMOD_ErrorString(FSOUND_GetError()));
return false;
}
ext_inited = false;
return inited = true;
}
int main()
{
FMUSIC_MODULE *mod = NULL;
if (FSOUND_GetVersion() < FMOD_VERSION)
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n", FMOD_VERSION);
exit(1);
}
/*
INITIALIZE
*/
if (!FSOUND_Init(32000, 64, 0))
{
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
exit(1);
}
/*
LOAD SONG
*/
mod = FMUSIC_LoadSong("../../media/invtro94.s3m");
if (!mod)
{
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
exit(1);
}
FMUSIC_PlaySong(mod);
/*
UPDATE INTERFACE
*/
printf("Press any key to quit\n");
printf("=========================================================================\n");
printf("Playing %s...\n", FMUSIC_GetName(mod));
do
{
printf("order = %d/%d, row = %d/%d channels playing = %d cpu usage = %.02f%% \r", FMUSIC_GetOrder(mod), FMUSIC_GetNumOrders(mod), FMUSIC_GetRow(mod), FMUSIC_GetPatternLength(mod, FMUSIC_GetOrder(mod)), FSOUND_GetChannelsPlaying(), FSOUND_GetCPUUsage());
Sleep(10);
} while (!kbhit());
getch();
printf("\n");
/*
FREE SONG AND SHUT DOWN
*/
FMUSIC_FreeSong(mod);
FSOUND_Close();
return 0;
}
//initialize sound system
CAudioManager::CAudioManager(){
m_bValidAudio = false;
if( FSOUND_Init(44000,64,0) == false ){
m_bValidAudio = false;
}
else{
m_bValidAudio = true;
m_MaxChannels = FSOUND_GetMaxChannels();
}
}
CSoundManager::CSoundManager()
{
m_bCanauxJeu = true;
// On initialise Fmod : Fréquence de sortie, nombre de canaux utilisés et option (non util pour nous)
FSOUND_Init (44100, CANAL_MAX, 0);
FSOUND_SetSFXMasterVolume (64);
// On initialise tous les canaux de sons à 0 pour pouvoir vérifier qu'ils sont utilisés ou non.
for (int Canal = CANAL_NULL; Canal < CANAL_MAX; Canal++)
m_pSon[Canal] = 0;
}
CAudio::CAudio(){
if (FSOUND_GetVersion() < FMOD_VERSION){
//SDL_SetError("FMOD.DLL version is old, please update it.");
return;
}
if (!FSOUND_Init(32000, 64, 0)){
//SDL_SetError(FMOD_ErrorString(FSOUND_GetError()));
return;
}
//return true;
}
// Initialization of Audio
bool HamurAudioManager::Init(int mixrate, int maxsoftwarechannels, unsigned int flags)
{
if(!FSOUND_Init(mixrate, maxsoftwarechannels, flags))
{
HAMURLOG->WriteLogln(FMOD_ErrorString(FSOUND_GetError()));
return false;
}
else
{
HAMURLOG->WriteInitLog("HamurAudioManager");
return true;
}
}
int cnsSynth_LoadMusic() {
#ifdef __DELTA
delta_decode(music_data,MUSICSIZE);
#endif
// FSOUND_File_SetCallbacks(memread, memseek, memtell);
FSOUND_File_Read=memread;
FSOUND_File_Seek=memseek;
FSOUND_File_Tell=memtell;
if (!FSOUND_Init(44100)) return 0;
mod=FMUSIC_LoadSong(sampleloadcallback,noteloadcallback);
return 1;
}
VOID CSoundSystemFMod::Initial(LPCTSTR szSndPath, LPCTSTR szDBCFile)
{
assert(szSndPath);
assert(szDBCFile);
if (FSOUND_GetVersion() < FMOD_VERSION)
{
throw("FMOD: You are using the wrong DLL version! Should be %.2f", FMOD_VERSION);
}
FSOUND_SetOutput(FSOUND_OUTPUT_WINMM);
FSOUND_SetDriver(0);
FSOUND_SetMixer(FSOUND_MIXER_AUTODETECT);
FSOUND_3D_SetRolloffFactor(0);
if(!FSOUND_Init(44100, 32, 0))
{
throw("Failed to create the FMod driver object");
}
m_strSoundPath = szSndPath;
m_strSndDBCFile = szDBCFile;
//查询资源定义
static DBC::DBCFile fileSnd(0);
BOOL fileOpened = fileSnd.OpenFromTXT(m_strSndDBCFile.c_str());
if (!fileOpened)
{
throw("Failed to open config file!");
}
INT nLineNum = (INT)fileSnd.GetRecordsNum();
for(INT i=0; i<nLineNum; i++)
{
const _DBC_SOUND_INFO* pDefine = (const _DBC_SOUND_INFO*)fileSnd.Search_Posistion(i, 0);
if(!pDefine) continue;
SOUND_BUFFER newSound;
newSound.pDefine = pDefine;
newSound.pSoundBuf = NULL;
//加入列表
m_listSoundBuffer.push_back(newSound);
//加入索引
m_mapSoundID[pDefine->nID] = &(m_listSoundBuffer.back());
m_mapSoundFile[pDefine->pSoundFile] = &(m_listSoundBuffer.back());
}
}
SoundSystem::SoundSystem(BlackBoardUID _uid, BlackBoard *_blackBoard)
: BlackBoardSubscriber(_uid, _blackBoard)
{
registerMessageHandler("MessagePlaySound", bind(&SoundSystem::handleMessagePlaySound, this, _1));
cache.clear();
soundVolume = 1.0f;
musicVolume = 0.5f;
mute = false;
musicStream = 0;
musicChannel = -1;
int mixrate = 44100;
int maxsoftwarechannels = 32;
unsigned int flags = 0;
FSOUND_Init(mixrate, maxsoftwarechannels, flags);
TRACE("Sound System initialized");
}
static inline BOOL M_InitMusic(VOID)
{
if (FSOUND_GetVersion() < FMOD_VERSION)
{
printf("Error : You are using the wrong DLL version!\nYou should be using FMOD %.02f\n", FMOD_VERSION);
return FALSE;
}
#ifdef _DEBUG
FSOUND_SetOutput(FSOUND_OUTPUT_WINMM);
#endif
if (!FSOUND_Init(44100, 1, FSOUND_INIT_GLOBALFOCUS))
{
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return FALSE;
}
return TRUE;
}
int CSound::Initialise(int rate,int channels,int svol,int mvol)
{
if((channels > 16) || (channels < 0))
{
return 1;
}
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
FSOUND_Init(rate,channels,FSOUND_INIT_USEDEFAULTMIDISYNTH);
songname = "Empty";
SetSoundVolume(svol);
SetMusicVolume(mvol);
CurrentSong = NULL;
CurrentSound = 0;
pan = 127;
freq = 11250;
FSOUND_Sample_Load(0,"sfx/click.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(1,"sfx/dong.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(3,"sfx/computer.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(4,"sfx/scitech.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(5,"sfx/speed.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(6,"sfx/placetrack.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(7,"sfx/removetrack.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(8, "sfx/click3.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(9, "sfx/pickuptrack.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(10, "sfx/cartexplode.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(11, "sfx/cart-good.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(12, "sfx/pickup.wav",FSOUND_LOOP_OFF,0);
FSOUND_Sample_Load(13, "sfx/crusher.wav",FSOUND_LOOP_OFF, 0);
return 0;
}
bool AudioDevice::init(Log* _debugLog) {
debugLog = _debugLog;
if (debugLog != NULL) {
debugLog->printf("Initializing audio system 44kHz 32 channels\n");
}
bool ret = FSOUND_Init(44100, 32, 0) != 0;
if (debugLog != NULL) {
if (ret) {
debugLog->println("Audio initalization Ok");
} else {
debugLog->println("Audio initalization FAIL");
}
}
return ret;
}
/// <summary> Initializes this object. </summary>
void CSound::Init()
{
// Upon verifying FSOUND is not initialized using 44100 mix rate, 32 channels, and zero flags; do nothing
// Otherwise, proceed with loading sounds and music into memory
if (!FSOUND_Init(44100,32,0))
{
}
else
{
// Upon verifying that sounds did not load report an error message and indicate sound has not loaded
if (!LoadSounds())
{
// Display message box informing user that sounds did not load
MessageBox(p->hWnd, "Failed to load sounds!", 0, 0);
// Set sound indicator to zero
p->Options->sound = 0;
// Save options
p->Options->SaveOptions();
}
// Upon verifying that music did not load report an error message and indicate music has not loaded
if (!LoadMusic())
{
// Display message box informing user that music did not load
MessageBox(p->hWnd, "Failed to load music!", 0, 0);
// Set music indicator to zero
p->Options->music = 0;
// Save options
p->Options->SaveOptions();
}
}
// Set random starting point based upon current game time interval
// http://msdn.microsoft.com/en-us/library/f0d4wb4t(v=vs.71).aspx
srand((unsigned int)p->Tick);
// Set the index to be zero plus the remainder of rand() divided by six
this->MIDIndex = 0 + (rand()%6);
// Play the music associated to the index
PlaYMID(MIDIndex);
// Start the Sound thread
_beginthread(thrSound,0,p);
}
bool CSoundManager::InitFMOD(SOUNDMANAGER_PARAMETERS smpp)
{
Protokoll.WriteText ("Initializing FMOD\n", false);
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND); // Output-Mode setzen
FSOUND_SetDriver(0); // Default-Soundkarte setzen
FSOUND_SetMixer(FSOUND_MIXER_QUALITY_AUTODETECT); // Mixer-Quality setzen
InitSuccessfull = (TRUE == FSOUND_Init(smpp.Mixrate, smpp.MaxSoftwareChannels, smpp.Flags));
if (false == InitSuccessfull)
{
Protokoll.WriteText ("\n->", false);
Protokoll.WriteText (GetFMODErrorString(FSOUND_GetError()), false);
return false;
}
MaxChannels = FSOUND_GetMaxChannels();
Protokoll.WriteText ("Successfull\n", false);
return true;
} // InitFMOD
char CFMOD::InitializeSound()
{
char x;
FSOUND_SetMinHardwareChannels(8);
FSOUND_SetMaxHardwareChannels(MAX_SND_CHANNELS);
x = FSOUND_Init(44100, MAX_SND_CHANNELS, 0);
Log->AddEntry(va("FMOD Version: %.2f started",FSOUND_GetVersion()));
if(x)
{
bfmod=1;
maxchannels=FSOUND_GetMaxChannels();
Log->AddEntry(va("FMOD Max Channels [%d]",maxchannels));
}
else
{
bfmod=0;
return 0;
}
SetSoundVolume(svol);
return x;
}
int put_song_bcast(t_sdl *sdl, int x, int y)
{
FSOUND_SAMPLE *turkey;
FSOUND_Init(44100, 32, 0);
sdl->game.rec.x = (x - sdl->scrollX) * MAP_W + 30;
sdl->game.rec.y = (y - sdl->scrollY) * MAP_H + HEADER_MENU + 10;
sdl->game.rec.h = 17;
sdl->game.rec.w = 17;
xSDL_BlitSurface(sdl->game.bcast, NULL, sdl->screen, &sdl->game.rec);
SDL_UpdateRects(sdl->screen, 1, &sdl->game.rec);
if ((turkey = FSOUND_Sample_Load(FSOUND_FREE, "src_graphic/sound/gobble.wav",
0, 0, 0)) == NULL)
{
my_printf("Warning: Sound loading failled\n");
SDL_Delay(1000);
return (0);
}
FSOUND_PlaySound(FSOUND_FREE, turkey);
SDL_Delay(1000);
FSOUND_Sample_Free(turkey);
FSOUND_Close();
return (1);
}
bool InitApp(HINSTANCE hInstance, int nCmdShow)
{
WNDCLASS WinClass;
//------------------------------------------------------------------
// Histoire d'avoir un joli fichier log
//------------------------------------------------------------------
debug << "---------------------------------------------------------------\n";
debug << "Blip & Blop - (c) LOADED Studio - " << __DATE__ << "\n";
debug << "---------------------------------------------------------------\n";
//------------------------------------------------------------------
// Precalculs mathématiques
//------------------------------------------------------------------
preCalcMathsFunctions();
//------------------------------------------------------------------
// FMOD / Sons
//------------------------------------------------------------------
if (!FSOUND_Init(22050, CHANNEL_NUMBER, 0)) {
Warning("Cannot initialise FMOD. Sound will be turned off.");
LOGI("BUG AUDIO");
sound_on = false;
music_on = false;
} else {
// Pour éviter que les musiques ne se fassent écraser par les sons
//
FSOUND_SetPriority(0, 255);
}
//------------------------------------------------------------------
// Timer
//------------------------------------------------------------------
LInitTimer();
//------------------------------------------------------------------
// Charge la configuration
//------------------------------------------------------------------
load_BB3_config(CONFIG_FILE);
//------------------------------------------------------------------
// Charge les hi scores
//------------------------------------------------------------------
hi_scores.init();
if (!hi_scores.load(HISCORES_FILE)) {
debug << "Cannot load hi-scores file. Use default hi-scores\n";
hi_scores.init();
} else {
debug << "Using " << HISCORES_FILE << " as hiscores file\n";
}
//------------------------------------------------------------------
// Les fichiers textes
//------------------------------------------------------------------
if (lang_type == LANG_UK) {
if (!loadTxtData("data/uk.dat")) {
Bug("Cannot open the file 'data/uk.dat'");
ReleaseAll();
return false;
}
} else {
if (!loadTxtData("data/fr.dat")) {
Bug("Cannot open the file 'data/fr.dat'");
ReleaseAll();
return false;
}
}
//------------------------------------------------------------------
// Direct Input
//------------------------------------------------------------------
if (!in.open(WinHandle, hInstance)) {
Bug("Cannot initialise DirectInput. Make sure DirectX 7 or better is installed.");
ReleaseAll();
return false;
}
debug << "DI Initialized\n";
//------------------------------------------------------------------
// Direct Draw (1ère partie)
//------------------------------------------------------------------
LOGI("first");
if (!DDInitDirectDraw()) {
Bug("Cannot initialise DirectDraw. Make sure DirectX 7 or better is installed.");
ReleaseAll();
return false;
}
debug << "DD Initialized\n";
active = true; //Activate the game loop
LOGI("second");
if (!DDSetCooperativeLevel(WinHandle)) {
Bug("Cannot get EXCLUSIVE MODE. Close all other applications and launch Blip'n Blop again");
ReleaseAll();
return false;
}
debug << "Exclusive mode set\n";
LOGI("third");
static const int BEST_RATE = 85;
if (safeMode) {
debug << "Safe mode enabled, using default 640x480x16 refresh rate.\n";
winSet = false;
if (!DDSetGfxMode(640, 480, 16)) {
Bug("Cannot set display mode to 640x480x16. Are you sure your video card meets the requirements ?");
ReleaseAll();
return false;
}
} else {
debug << "Trying to create window\n";
if (!DDSetGfxMode(640, 480, 16)) {
Bug("Cannot set display mode to 640x480x16. Are you sure your video card meets the requirements ?");
ReleaseAll();
return false;
}
debug << "Window creation done\n";
}
LOGI("fouth");
//------------------------------------------------------------------
// Direct Draw (suite)
//------------------------------------------------------------------
// Crée la surface primaire avec double buffer
debug << "Creating primSurface\n";
primSurface = DDCreatePrimary(backSurface);
if (primSurface == NULL || backSurface == NULL) {
Bug("Cannot get a primary surface. Please reboot your PC and try to launch Blip'n Blop again.\nBe sure you have at least 2 Mb of video memory on your video card.");
ReleaseAll();
return false;
}
debug << "primSurface created\n";
LOGI("fifth");
//------------------------------------------------------------------
// Surface système
//------------------------------------------------------------------
debug << "Creating systemSurface\n";
systemSurface = DDCreateSurface(640, 480, DDSURF_SYSTEM);
if (systemSurface == NULL) {
Bug("Not enough memory. Blip'n Blop needs 32 Mo of free memory. Try to close all other applications and launch Blip'n Blop again.");
ReleaseAll();
return false;
}
debug << "systemSurface created\n";
LOGI("sixth");
//------------------------------------------------------------------
// LGX paker
//------------------------------------------------------------------
debug << "Initializing LGXpaker\n";
if (!LGXpaker.init(primSurface)) {
Bug("Cannot initialise LGX paker. Please get the latest drivers for your video card.");
ReleaseAll();
return false;
}
debug << "LGXpaker initialized\n";
LOGI("seventh");
//------------------------------------------------------------------
// Scroll buffers
//------------------------------------------------------------------
debug << "Creating video buffer of size " << (WANTED_VBUFFER_WIDE) << "...";
videoA = DDCreateSurface(WANTED_VBUFFER_WIDE, 480, DDSURF_VIDEO);
if (videoA == NULL) {
debug << "Failed\n";
debug << "Creating video buffer of size " << (WANTED_VBUFFER_WIDE - 100) << "...";
videoA = DDCreateSurface(WANTED_VBUFFER_WIDE - 100, 480, DDSURF_VIDEO);
if (videoA == NULL) {
debug << "Failed\n";
debug << "Creating video buffer (" << (WANTED_VBUFFER_WIDE - 200) << ")...";
videoA = DDCreateSurface(WANTED_VBUFFER_WIDE - 200, 480, DDSURF_VIDEO);
if (videoA == NULL) {
debug << "Failed\n";
videoA = DDCreateSurface(WANTED_VBUFFER_WIDE, 480, DDSURF_SYSTEM);
if (videoA == NULL) {
Bug("Not enough memory. Blip'n Blop needs 32 Mo of free memory. Try to close all other applications and launch Blip'n Blop again.");
ReleaseAll();
return false;
}
debug << "Cannot create video buffer. Use system buffer instead.\n";
vbuffer_wide = WANTED_VBUFFER_WIDE;
mem_flag = DDSURF_SYSTEM;
video_buffer_on = false;
} else {
debug << "Ok\n";
vbuffer_wide = WANTED_VBUFFER_WIDE - 200;
}
} else {
debug << "Ok\n";
vbuffer_wide = WANTED_VBUFFER_WIDE - 100;
}
} else {
debug << "Ok\n";
vbuffer_wide = WANTED_VBUFFER_WIDE;
}
LOGI("eighth");
//------------------------------------------------------------------
// Chargement des fontes init
//------------------------------------------------------------------
if (!fnt_menu.load("data/menu.lft", mem_flag)) {
Bug("Cannot open the file data/menu.lft");
ReleaseAll();
return false;
}
LOGI("nineth");
if (!fnt_menus.load("data/menus.lft", mem_flag)) {
Bug("Cannot open the file data/menus.lft");
ReleaseAll();
return false;
}
if (!fnt_cool.load("data/cool.lft", mem_flag)) {
Bug("Cannot open the file data/cool.lft");
ReleaseAll();
return false;
}
if (!fnt_rpg.load("data/rpg.lft", mem_flag)) {
Bug("Cannot open the file data/rpg.lft");
ReleaseAll();
return false;
}
LOGI("erz");
//------------------------------------------------------------------
// Chargement de l'interface
//------------------------------------------------------------------
if (!pbk_inter.loadGFX("data/inter.gfx", DDSURF_BEST)) {
debug << "Cannot load interface.\n";
return false;
} else {
debug << "Successfully loaded interface.\n";
}
if (!mbk_inter.open("data/inter.mbk", false)) {
debug << "Cannot load interface musics.\n";
return false;
}
if (!mbk_interl.open("data/interl.mbk", true)) {
debug << "Cannot load interface musics (p2).\n";
return false;
}
LOGI("END");
//------------------------------------------------------------------
// Mémoire video restante
//------------------------------------------------------------------
//------------------------------------------------------------------
// Mise en place du TIMER pour obtenir les FPS
//------------------------------------------------------------------
SetTimer(WinHandle, 1, 1000, NULL);
return true; // C'est fini!
} // Init ---------------------------
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
int main(int argc, char *argv[])
{
FSOUND_STREAM *stream;
int read_percent = 0, i, driver = 0, channel = -1, status = 0, openstate, bitrate;
unsigned int flags;
char s[256] = "";
char key;
if (FSOUND_GetVersion() < FMOD_VERSION)
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n", FMOD_VERSION);
return 1;
}
if ((argc < 2) || (strnicmp(argv[1], "http:", 5)))
{
printf("-------------------------------------------------------------\n");
printf("FMOD netstream example.\n");
printf("Copyright (c) Firelight Technologies Pty, Ltd, 1999-2004.\n");
printf("-------------------------------------------------------------\n");
printf("Syntax: netstream <url>\n");
printf("Example: netstream http://www.fmod.org/stream.mp3\n\n");
return 1;
}
#if defined(WIN32) || defined(_WIN64) || defined(__CYGWIN32__) || defined(__WATCOMC__)
FSOUND_SetOutput(FSOUND_OUTPUT_DSOUND);
#elif defined(__linux__)
FSOUND_SetOutput(FSOUND_OUTPUT_OSS);
#endif
// ==========================================================================================
// SELECT DRIVER
// ==========================================================================================
printf("---------------------------------------------------------\n");
switch (FSOUND_GetOutput())
{
case FSOUND_OUTPUT_NOSOUND: printf("NoSound"); break;
case FSOUND_OUTPUT_WINMM: printf("Windows Multimedia Waveout"); break;
case FSOUND_OUTPUT_DSOUND: printf("Direct Sound"); break;
case FSOUND_OUTPUT_A3D: printf("A3D"); break;
case FSOUND_OUTPUT_OSS: printf("Open Sound System"); break;
case FSOUND_OUTPUT_ESD: printf("Enlightenment Sound Daemon"); break;
case FSOUND_OUTPUT_ALSA: printf("ALSA"); break;
};
printf(" Driver list\n");
printf("---------------------------------------------------------\n");
for (i=0; i < FSOUND_GetNumDrivers(); i++)
{
printf("%d - %s\n", i+1, FSOUND_GetDriverName(i));
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
key = getch();
if (key == 27) exit(0);
driver = key - '1';
} while (driver < 0 || driver >= FSOUND_GetNumDrivers());
FSOUND_SetDriver(driver);
// ==========================================================================================
// INITIALIZE
// ==========================================================================================
if (!FSOUND_Init(44100, 32, 0))
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
FSOUND_Close();
return 1;
}
/*
Internet streams can work with a much smaller stream buffer than normal streams because they
use another level of buffering on top of the stream buffer.
*/
FSOUND_Stream_SetBufferSize(100);
/*
Here's where we set the size of the network buffer and some buffering parameters.
In this case we want a network buffer of 64k, we want it to prebuffer 60% of that when we first
connect, and we want it to rebuffer 80% of that whenever we encounter a buffer underrun.
*/
FSOUND_Stream_Net_SetBufferProperties(64000, 60, 80);
/*
Open the stream using FSOUND_NONBLOCKING because the connect/buffer process might take a long time
*/
stream = FSOUND_Stream_Open(argv[1], FSOUND_NORMAL | FSOUND_NONBLOCKING, 0, 0);
if (!stream)
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
FSOUND_Close();
return 1;
}
printf("\nPress ESC to quit...\n\n");
key = 0;
do
{
if (kbhit())
{
key = getch();
}
/*
Play the stream if it's not already playing
*/
if (channel < 0)
{
channel = FSOUND_Stream_PlayEx(FSOUND_FREE, stream, NULL, TRUE);
FSOUND_SetPaused(channel, FALSE);
if (channel != -1)
{
FSOUND_Stream_Net_SetMetadataCallback(stream, metacallback, 0);
}
}
openstate = FSOUND_Stream_GetOpenState(stream);
if ((openstate == -1) || (openstate == -3))
{
printf("\nERROR: failed to open stream!\n");
printf("SERVER: %s\n", FSOUND_Stream_Net_GetLastServerStatus());
break;
}
FSOUND_Stream_Net_GetStatus(stream, &status, &read_percent, &bitrate, &flags);
/*
Show how much of the net buffer is used and what the status is
*/
if (metanum)
{
printf("%s - %s\n", artist, title);
metanum = 0;
}
s[0] = 0;
strncat(s, bar, (read_percent >> 1) + (read_percent & 1));
strncat(s, nobar, (100 - read_percent) >> 1);
printf("|%s| %d%% %s\r", s, read_percent, status_str[status]);
Sleep(16);
} while (key != 27);
printf("\n");
FSOUND_Stream_Close(stream);
FSOUND_Close();
return 0;
}
void gli_initialize_sound(void)
{
if (gli_conf_sound == 1)
if (!FSOUND_Init(44100, 32, FSOUND_INIT_USEDEFAULTMIDISYNTH))
gli_conf_sound = 0;
}
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
int main()
{
FSOUND_SAMPLE *samp1 = 0, *samp2 = 0;
int key;
int eqid1,eqid2;
if (FSOUND_GetVersion() < FMOD_VERSION)
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n", FMOD_VERSION);
return 1;
}
/*
INITIALIZE
*/
FSOUND_SetBufferSize(100); /* This is nescessary to get FX to work on output buffer */
if (!FSOUND_Init(44100, 32, FSOUND_INIT_ENABLESYSTEMCHANNELFX))
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
/*
LOAD SAMPLES
*/
/* PCM,44,100 Hz, 8 Bit, Mono */
samp1 = FSOUND_Sample_Load(FSOUND_FREE, "../../media/drumloop.wav", FSOUND_2D, 0, 0);
if (!samp1)
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
FSOUND_Sample_SetMode(samp1, FSOUND_LOOP_OFF);
/* PCM,44,100 Hz, 16 Bit, Stereo */
samp2 = FSOUND_Sample_Load(FSOUND_FREE, "../../media/jules.mp3", FSOUND_HW2D | FSOUND_ENABLEFX, 0, 0);
if (!samp2)
{
printf("Error!\n");
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
return 1;
}
/*
DISPLAY HELP
*/
printf("FSOUND Output Method : ");
switch (FSOUND_GetOutput())
{
case FSOUND_OUTPUT_NOSOUND: printf("FSOUND_OUTPUT_NOSOUND\n"); break;
case FSOUND_OUTPUT_WINMM: printf("FSOUND_OUTPUT_WINMM\n"); break;
case FSOUND_OUTPUT_DSOUND: printf("FSOUND_OUTPUT_DSOUND\n"); break;
case FSOUND_OUTPUT_ASIO: printf("FSOUND_OUTPUT_ASIO\n"); break;
case FSOUND_OUTPUT_OSS: printf("FSOUND_OUTPUT_OSS\n"); break;
case FSOUND_OUTPUT_ALSA: printf("FSOUND_OUTPUT_ALSA\n"); break;
case FSOUND_OUTPUT_ESD: printf("FSOUND_OUTPUT_ESD\n"); break;
};
printf("FSOUND Mixer : ");
switch (FSOUND_GetMixer())
{
case FSOUND_MIXER_QUALITY_FPU: printf("FSOUND_MIXER_QUALITY_FPU\n"); break;
case FSOUND_MIXER_QUALITY_MMXP5: printf("FSOUND_MIXER_QUALITY_MMXP5\n"); break;
case FSOUND_MIXER_QUALITY_MMXP6: printf("FSOUND_MIXER_QUALITY_MMXP6\n"); break;
};
printf("FSOUND Driver : %s\n", FSOUND_GetDriverName(FSOUND_GetDriver()));
printf("=========================================================================\n");
printf("Press 1 Play SOFTWARE sound affected by following reverb dsp unit (wet)\n");
printf(" 2 Play SOFTWARE sound unaffected by following reverb dsp unit (dry)\n");
if (FSOUND_GetOutput() == FSOUND_OUTPUT_DSOUND)
{
printf(" 3 Play HARDWARE FX enabled sound using Direct X 8 (echo+flange)\n");
printf(" 4 Set EQ on global software output to be affect by DX8 FX\n");
printf(" Press 1 or 2 to hear the effect (3 is unaffected)\n");
printf(" 5 Turn off EQ on global software output\n");
}
printf(" ESC Quit\n");
printf("=========================================================================\n");
/*
SET UP DSPS!
*/
SetupReverb();
/*
Note if we are using a dsp unit for playing sounds, callback and parameter are ignored!
*/
DrySFXUnit = FSOUND_DSP_Create(NULL, FSOUND_DSP_DEFAULTPRIORITY_USER+100, 0);
FSOUND_DSP_SetActive(DrySFXUnit, TRUE);
/*
You must pause the software output before getting the FX handle on it.
*/
if (FSOUND_GetOutput() == FSOUND_OUTPUT_DSOUND)
{
FSOUND_SetPaused(FSOUND_SYSTEMCHANNEL, TRUE);
eqid1 = FSOUND_FX_Enable(FSOUND_SYSTEMCHANNEL, FSOUND_FX_PARAMEQ);
eqid2 = FSOUND_FX_Enable(FSOUND_SYSTEMCHANNEL, FSOUND_FX_PARAMEQ);
FSOUND_SetPaused(FSOUND_SYSTEMCHANNEL, FALSE);
}
/*
START PLAYING!
*/
do
{
key = 0;
printf("channels playing = %d cpu usage = %.02f%%\r", FSOUND_GetChannelsPlaying(), FSOUND_GetCPUUsage());
if (kbhit())
{
key = getch();
if (key == '1')
{
int channel = FSOUND_PlaySound(FSOUND_FREE, samp1);
}
if (key == '2')
{
FSOUND_PlaySoundEx(FSOUND_FREE, samp1, DrySFXUnit, FALSE);
}
if (FSOUND_GetOutput() == FSOUND_OUTPUT_DSOUND)
{
if (key == '3')
{
static int fxchannel = FSOUND_FREE;
static int echoid = -1, echoid2 = -1,flangeid = -1, firsttime;
if (fxchannel == FSOUND_FREE)
{
firsttime = TRUE;
}
else
{
firsttime = FALSE;
}
fxchannel = FSOUND_PlaySoundEx(fxchannel, samp2, DrySFXUnit, TRUE);
/*
NOTE! Even though it is for hardware FX, set it to a DrySFXUnit just
in case a non hardware output mode has been selected (such as
WINMM/Linux etc) and it actually drops back to 100% software
*/
FSOUND_SetVolume(fxchannel, 120); /* turn it down a bit! */
if (firsttime)
{
echoid = FSOUND_FX_Enable(fxchannel, FSOUND_FX_ECHO);
echoid2 = FSOUND_FX_Enable(fxchannel, FSOUND_FX_ECHO);
flangeid = FSOUND_FX_Enable(fxchannel, FSOUND_FX_FLANGER);
}
FSOUND_SetPaused(fxchannel, FALSE);
FSOUND_FX_SetEcho(echoid, 80.0f, 70.0f, 100.0f, 100.0f, TRUE);
FSOUND_FX_SetEcho(echoid2, 100, 70.0f, 10, 10, FALSE);
}
if (key == '4')
{
FSOUND_FX_SetParamEQ(eqid1, 8000, 36, -15);
FSOUND_FX_SetParamEQ(eqid2, 16000, 36, -15);
}
if (key == '5')
{
FSOUND_FX_SetParamEQ(eqid1, 8000, 15, 0);
FSOUND_FX_SetParamEQ(eqid2, 8000, 15, 0);
}
}
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
CLEANUP AND SHUTDOWN
*/
FSOUND_DSP_Free(DrySFXUnit);
CloseReverb();
FSOUND_Sample_Free(samp1);
FSOUND_Sample_Free(samp2);
FSOUND_Close();
return 0;
}
void init()
{
memset(lastfilename,0,256);
memset(musfilename,0,40);
initGUI();
sprintf(scenelist->name,"Default");
memset(tooltip,0,256);
memset(defaulttooltip,0,256);
sprintf(defaulttooltip,"a.D.D.i.c.t. (c) BoyC 2002");
actualtexture=texturelist;
lasttexture=texturelist;
memset(texturelist,0,sizeof(tTexture));
texturelist->next=NULL;
sprintf(texturelist->name,"Default");
memset(cursorstring,0,256);
for (x=0;x<=7;x++) modellsubmenu[x]=0;
init3dengine();
InitModellerGUI();
BuildFont();
BuildFont2();
BuildFontSmall();
inittextureengine();
generatedtexture.init();
buffertexture.init();
memset(pretextures,0,sizeof(pretextures));
memset(texdata,0,sizeof(texdata));
memset(texsubmenu,0,sizeof(texsubmenu));
texdata[0][3].command[3]=4;
texdata[0][5].command[3]=14;
texdata[0][5].command[4]=100;
texdata[0][6].command[3]=30;
texdata[1][1].command[2]=128;
texdata[2][4].command[3]=128;
texdata[3][2].command[2]=128;
texdata[3][4].command[4]=255;
texdata[3][6].c.param1=255;
texdata[3][6].c.param3=255;
texdata[3][6].c.param5=255;
glGenTextures(1,&mattexture);
glBindTexture(GL_TEXTURE_2D,mattexture);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,4,256,256,0,GL_RGBA,GL_UNSIGNED_BYTE,generatedtexture.layers[0]);
for (x=0;x<4;x++)
{
glGenTextures(1,&(prelayers[x]));
glBindTexture(GL_TEXTURE_2D,prelayers[x]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,4,256,256,0,GL_RGBA,GL_UNSIGNED_BYTE,generatedtexture.layers[x]);
}
for (x=0;x<4;x++)
{
glGenTextures(1,&(texlayers[x]));
glBindTexture(GL_TEXTURE_2D,texlayers[x]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,4,256,256,0,GL_RGBA,GL_UNSIGNED_BYTE,generatedtexture.layers[x]);
}
for (x=0;x<4;x++)
{
glGenTextures(1,&alayers[x]);
glBindTexture(GL_TEXTURE_2D,alayers[x]);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D,0,4,256,256,0,GL_RGBA,GL_UNSIGNED_BYTE,generatedtexture.layers[x]);
}
glGenTextures(1,&background);
glBindTexture(GL_TEXTURE_2D, background);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
commandnames[DD_fractal] ="Fractal ";
commandnames[DD_plasma] ="Plasma ";
commandnames[DD_cells] ="Cells ";
commandnames[DD_envmap] ="Envmap ";
commandnames[DD_subplasm] ="Subplasma ";
commandnames[DD_clear] ="Clear ";
commandnames[DD_text] ="Text ";
commandnames[DD_sindist] ="SinDist ";
commandnames[DD_offset] ="Offset ";
commandnames[DD_twirl] ="Twirl ";
commandnames[DD_blur] ="Blur ";
commandnames[DD_map] ="MapDist ";
commandnames[DD_dirblur] ="DirBlur ";
commandnames[DD_xchng] ="Xchange ";
commandnames[DD_copy] ="Copy ";
commandnames[DD_mix] ="Mix ";
commandnames[DD_mul] ="Mul ";
commandnames[DD_add] ="Add ";
commandnames[DD_max] ="Max ";
commandnames[DD_contrast] ="Contrast ";
commandnames[DD_invert] ="Invert ";
commandnames[DD_shade] ="Shade ";
commandnames[DD_bright] ="Brighten ";
commandnames[DD_sincol] ="Color Sine ";
commandnames[DD_scale] ="Scale ";
commandnames[DD_hsv] ="HSV ";
commandnames[DD_colorize] ="Colorize ";
commandnames[DD_mixmap] ="MixMap ";
commandnames[DD_emboss] ="Emboss ";
commandnames[DD_stored] ="Stored ";
initkeyframergui();
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
FSOUND_Init(44100,32);
}
int main(int argc, char *argv[])
{
SDL_Event event;
int continuer = 1;
SDL_Init(SDL_INIT_VIDEO);
FSOUND_Init(44100, 32, FSOUND_NORMAL);
atexit(SDL_Quit);
SDL_WM_SetCaption("Sphere Quantique", NULL);
SDL_SetVideoMode(1280/*glutGet(GLUT_SCREEN_WIDTH)*/,720/*glutGet(GLUT_SCREEN_HEIGHT)*/, 32, SDL_OPENGL | SDL_NOFRAME/*| SDL_FULLSCREEN*/);
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective(70,(double)glutGet(GLUT_SCREEN_WIDTH)/glutGet(GLUT_SCREEN_HEIGHT),1,1000);
glEnable(GL_DEPTH_TEST);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glFlush();
SDL_GL_SwapBuffers();
srand(time(NULL));
for(int i=0;i<MAX_BALL;i++){
int r_x = rand()%(50-1)+10;
int r_y = rand()%(50-1)+10;
int r_z = rand()%(50-1)+10;
int ax_1 = rand()%2;
int ax_2 = rand()%2;
int angl = rand()%360;
int R = rand()%256;
int G = rand()%256;
int B = rand()%256;
sphere[i] = init_sphere(sphere[i],0,0,0,r_x,r_y,r_z,ax_1,ax_2,angl,R,G,B);
}
//SDL_Delay(10000);
while(continuer)
{
SDL_PollEvent(&event);
switch(event.type)
{ case SDL_QUIT:
continuer = 0;
break;
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{ case SDLK_ESCAPE:
continuer = 0;
break;
case SDLK_w:
cam_x += 1;
cam_px += 1;
break;
case SDLK_a:
break;
case SDLK_d:
break;
case SDLK_s:
cam_x -= 1;
cam_px -= 1;
break;
default:break;
}
break;
}
Dessiner();
SDL_Delay(10);
}
FSOUND_Close();
return 0;
}
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
void main(int argc, char *argv[])
{
#ifdef USEFMOD
FMUSIC_MODULE *mod;
#ifndef USEMEMLOAD
FSOUND_File_SetCallbacks(fileopen, fileclose, fileread, fileseek, filetell);
#else
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
#endif
#endif
if (argc < 2)
{
printf("-------------------------------------------------------------\n");
printf("MINIFMOD example XM player.\n");
printf("Copyright (c) Firelight Multimedia, 2000.\n");
printf("-------------------------------------------------------------\n");
printf("Syntax: simplest infile.xm\n\n");
return;
}
#ifdef USEFMOD
// ==========================================================================================
// INITIALIZE
// ==========================================================================================
if (!FSOUND_Init(44100, 0))
{
printf("Error upon initialization\n");
return;
}
// ==========================================================================================
// LOAD SONG
// ==========================================================================================
mod = FMUSIC_LoadSong(argv[1], NULL); //sampleloadcallback);
if (!mod)
{
printf("Error loading song\n");
return;
}
// ==========================================================================================
// PLAY SONG
// ==========================================================================================
FMUSIC_PlaySong(mod);
#endif
printf("Press any key to quit\n");
printf("=========================================================================\n");
printf("Playing song...\n");
{
char key = 0;
do
{
int ord = 0, row = 0;
float mytime = 0;
if (kbhit())
{
key = getch();
}
#ifdef USEFMOD
ord = FMUSIC_GetOrder(mod);
row = FMUSIC_GetRow(mod);
mytime = (float)FMUSIC_GetTime(mod) / 1000.0f;
#endif
printf("ord %2d row %2d seconds %5.02f %s \r", ord, row, mytime, (row % 8 ? " " : "TICK"));
} while (key != 27);
}
printf("\n");
#ifdef USEFMOD
FMUSIC_FreeSong(mod);
FSOUND_Close();
#endif
}
bool LLAudioEngine_FMOD::init(const S32 num_channels, void* userdata)
{
LLAudioEngine::init(num_channels, userdata);
// Reserve one extra channel for the http stream.
if (!FSOUND_SetMinHardwareChannels(num_channels + 1))
{
LL_WARNS("AppInit") << "FMOD::init[0](), error: " << FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
}
LL_DEBUGS("AppInit") << "LLAudioEngine_FMOD::init() initializing FMOD" << LL_ENDL;
F32 version = FSOUND_GetVersion();
if (version < FMOD_VERSION)
{
LL_WARNS("AppInit") << "Error : You are using the wrong FMOD version (" << version
<< ")! You should be using FMOD " << FMOD_VERSION << LL_ENDL;
//return false;
}
U32 fmod_flags = 0x0;
#if LL_WINDOWS
// Windows needs to know which window is frontmost.
// This must be called before FSOUND_Init() per the FMOD docs.
// This could be used to let FMOD handle muting when we lose focus,
// but we don't actually want to do that because we want to distinguish
// between minimized and not-focused states.
if (!FSOUND_SetHWND(userdata))
{
LL_WARNS("AppInit") << "Error setting FMOD window: "
<< FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
return false;
}
// Play audio when we don't have focus.
// (For example, IM client on top of us.)
// This means we also try to play audio when minimized,
// so we manually handle muting in that case. JC
fmod_flags |= FSOUND_INIT_GLOBALFOCUS;
fmod_flags |= FSOUND_INIT_DSOUND_HRTF_FULL;
#endif
#if LL_LINUX
// initialize the FMOD engine
// This is a hack to use only FMOD's basic FPU mixer
// when the LL_VALGRIND environmental variable is set,
// otherwise valgrind will fall over on FMOD's MMX detection
if (getenv("LL_VALGRIND")) /*Flawfinder: ignore*/
{
LL_INFOS("AppInit") << "Pacifying valgrind in FMOD init." << LL_ENDL;
FSOUND_SetMixer(FSOUND_MIXER_QUALITY_FPU);
}
// If we don't set an output method, Linux FMOD always
// decides on OSS and fails otherwise. So we'll manually
// try ESD, then OSS, then ALSA.
// Why this order? See SL-13250, but in short, OSS emulated
// on top of ALSA is ironically more reliable than raw ALSA.
// Ack, and ESD has more reliable failure modes - but has worse
// latency - than all of them, so wins for now.
bool audio_ok = false;
if (!audio_ok)
{
if (NULL == getenv("LL_BAD_FMOD_ESD")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying ESD audio output..." << LL_ENDL;
if(FSOUND_SetOutput(FSOUND_OUTPUT_ESD) &&
FSOUND_Init(44100, num_channels, fmod_flags))
{
LL_DEBUGS("AppInit") << "ESD audio output initialized OKAY"
<< LL_ENDL;
audio_ok = true;
} else {
LL_WARNS("AppInit") << "ESD audio output FAILED to initialize: "
<< FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
}
} else {
LL_DEBUGS("AppInit") << "ESD audio output SKIPPED" << LL_ENDL;
}
}
if (!audio_ok)
{
if (NULL == getenv("LL_BAD_FMOD_OSS")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying OSS audio output..." << LL_ENDL;
if(FSOUND_SetOutput(FSOUND_OUTPUT_OSS) &&
FSOUND_Init(44100, num_channels, fmod_flags))
{
LL_DEBUGS("AppInit") << "OSS audio output initialized OKAY" << LL_ENDL;
audio_ok = true;
} else {
LL_WARNS("AppInit") << "OSS audio output FAILED to initialize: "
<< FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
}
} else {
LL_DEBUGS("AppInit") << "OSS audio output SKIPPED" << LL_ENDL;
}
}
if (!audio_ok)
{
if (NULL == getenv("LL_BAD_FMOD_ALSA")) /*Flawfinder: ignore*/
{
LL_DEBUGS("AppInit") << "Trying ALSA audio output..." << LL_ENDL;
if(FSOUND_SetOutput(FSOUND_OUTPUT_ALSA) &&
FSOUND_Init(44100, num_channels, fmod_flags))
{
LL_DEBUGS("AppInit") << "ALSA audio output initialized OKAY" << LL_ENDL;
audio_ok = true;
} else {
LL_WARNS("AppInit") << "ALSA audio output FAILED to initialize: "
<< FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
}
} else {
LL_DEBUGS("AppInit") << "OSS audio output SKIPPED" << LL_ENDL;
}
}
if (!audio_ok)
{
LL_WARNS("AppInit") << "Overall audio init failure." << LL_ENDL;
return false;
}
// On Linux, FMOD causes a SIGPIPE for some netstream error
// conditions (an FMOD bug); ignore SIGPIPE so it doesn't crash us.
// NOW FIXED in FMOD 3.x since 2006-10-01.
//signal(SIGPIPE, SIG_IGN);
// We're interested in logging which output method we
// ended up with, for QA purposes.
switch (FSOUND_GetOutput())
{
case FSOUND_OUTPUT_NOSOUND: LL_DEBUGS("AppInit") << "Audio output: NoSound" << LL_ENDL; break;
case FSOUND_OUTPUT_OSS: LL_DEBUGS("AppInit") << "Audio output: OSS" << LL_ENDL; break;
case FSOUND_OUTPUT_ESD: LL_DEBUGS("AppInit") << "Audio output: ESD" << LL_ENDL; break;
case FSOUND_OUTPUT_ALSA: LL_DEBUGS("AppInit") << "Audio output: ALSA" << LL_ENDL; break;
default: LL_INFOS("AppInit") << "Audio output: Unknown!" << LL_ENDL; break;
};
#else // LL_LINUX
// initialize the FMOD engine
if (!FSOUND_Init(44100, num_channels, fmod_flags))
{
LL_WARNS("AppInit") << "Error initializing FMOD: "
<< FMOD_ErrorString(FSOUND_GetError()) << LL_ENDL;
return false;
}
#endif
// set up our favourite FMOD-native streaming audio implementation if none has already been added
if (!getStreamingAudioImpl()) // no existing implementation added
setStreamingAudioImpl(new LLStreamingAudio_FMOD());
LL_DEBUGS("AppInit") << "LLAudioEngine_FMOD::init() FMOD initialized correctly" << LL_ENDL;
mInited = true;
return true;
}
int CMusikPlayer::InitializeFMOD( int nFunction )
{
if ( ( nFunction == FMOD_INIT_RESTART ) || ( nFunction == FMOD_INIT_STOP ) )
Shutdown( false );
FSOUND_Close();
//---------------------//
//--- setup driver ---//
//---------------------//
if ( ( nFunction == FMOD_INIT_START ) || ( nFunction == FMOD_INIT_RESTART ) )
{
//-----------------//
//--- windows ---//
//-----------------//
#if defined(__WXMSW__)
if ( wxGetApp().Prefs.nSndOutput == 0 )
{
if( FSOUND_SetOutput( FSOUND_OUTPUT_DSOUND ) == FALSE )
return FMOD_INIT_ERROR_DSOUND;
}
else if ( wxGetApp().Prefs.nSndOutput == 1 )
{
if ( FSOUND_SetOutput( FSOUND_OUTPUT_WINMM ) == FALSE )
return FMOD_INIT_ERROR_WINDOWS_WAVEFORM;
}
else if ( wxGetApp().Prefs.nSndOutput == 2 )
{
if ( FSOUND_SetOutput( FSOUND_OUTPUT_ASIO ) == FALSE )
return FMOD_INIT_ERROR_ASIO;
}
//-----------------//
//--- linux ---//
//-----------------//
#elif defined (__WXGTK__)
if ( wxGetApp().Prefs.nSndOutput == 0 )
{
if( FSOUND_SetOutput( FSOUND_OUTPUT_OSS ) == FALSE )
return FMOD_INIT_ERROR_OSS;
}
else if ( wxGetApp().Prefs.nSndOutput == 1 )
{
if ( FSOUND_SetOutput( FSOUND_OUTPUT_ESD ) == FALSE )
return FMOD_INIT_ERROR_ESD;
}
else if ( wxGetApp().Prefs.nSndOutput == 2 )
{
if ( FSOUND_SetOutput( FSOUND_OUTPUT_ALSA ) == FALSE )
return FMOD_INIT_ERROR_ALSA;
}
#elif defined (__WXMAC__)
if( FSOUND_SetOutput( FSOUND_OUTPUT_MAC ) == FALSE )
return FMOD_INIT_ERROR_MAC;
#endif
if(wxGetApp().Prefs.nSndDevice > 0)
{
//---------------------//
//--- setup device ---//
//---------------------//
if ( FSOUND_SetDriver( wxGetApp().Prefs.nSndDevice ) == FALSE )
return FMOD_INIT_ERROR_DEVICE_NOT_READY;
}
// initialize system
#ifdef __WXMAC__
FSOUND_SetBufferSize( 1000 );
#else
FSOUND_SetBufferSize( 100 );
#endif
InitFMOD_NetBuffer();
InitFMOD_ProxyServer();
if ( FSOUND_Init( wxGetApp().Prefs.nSndRate , wxGetApp().Prefs.nSndMaxChan, 0 ) == FALSE )
return FMOD_INIT_ERROR_INIT;
// wxGetApp().Prefs.nSndOutput = FSOUND_GetOutput();
}
return FMOD_INIT_SUCCESS;
}
