void Sound::Init(int _channels) { s_result = FMOD_System_Create(&s_fmod_system); assert(s_result == FMOD_OK); //Initializes the system with 1 channel s_result = FMOD_System_Init(s_fmod_system, _channels, FMOD_INIT_NORMAL, 0); assert(s_result == FMOD_OK); FMOD_Channel_SetVolume(s_channel, 0.0f); }
bool QSPCallBacks::SetVolume(QSPString file, int volume) { if (!IsPlay(file)) return false; QSPSounds::iterator elem = m_sounds.find(wxFileName(wxString(file.Str, file.End), wxPATH_DOS).GetFullPath().Upper()); QSPSound *snd = (QSPSound *)&elem->second; snd->Volume = volume; FMOD_Channel_SetVolume(snd->Channel, (float)(m_volumeCoeff * volume) / 100); return true; }
void play(){ if(sound){ FMOD_RESULT result = FMOD_System_PlaySound(System, FMOD_CHANNEL_FREE, sound, false, &channel); if(result == FMOD_OK){ FMOD_Channel_SetVolume(channel, Config.EffectVolume); FMOD_System_Update(System); } } }
void Sound::init() { //create the sound system. If fails, sound is set to impossible result = FMOD_System_Create(&fmodsystem); if (result != FMOD_OK) possible = false; //if initialise the sound system. If fails, sound is set to impossible if (possible) result = FMOD_System_Init(fmodsystem, 2, FMOD_INIT_NORMAL, 0); if (result != FMOD_OK) possible = false; //sets initial sound volume (mute) if (possible) {FMOD_Channel_SetVolume(channel, 0.0f); printf("sadsad\n");} }
void Systems::SoundSystem::PlaySound(FMOD_CHANNEL** channel, FMOD_SOUND* sound, float volume, bool loop) { FMOD_System_PlaySound(m_System, FMOD_CHANNEL_FREE, sound, false, channel); FMOD_Channel_SetVolume(*channel, volume); if(loop) { FMOD_Channel_SetMode(*channel, FMOD_LOOP_NORMAL); FMOD_Sound_SetLoopCount(sound, -1); } }
void play(const bool doubleVolume = false) { if (sound) { FMOD_RESULT result = FMOD_System_PlaySound(System, FMOD_CHANNEL_FREE, sound, false, &channel); if (result == FMOD_OK) { FMOD_Channel_SetVolume(channel, (doubleVolume ? 2 : 1) * Config.EffectVolume); FMOD_System_Update(System); } } }
void Sound::play(float vol){ if(vol==0)return; FMOD_RESULT r; if( !this->ch ){ r = FMOD_System_PlaySound( parent->sys, FMOD_CHANNEL_FREE, sound, 0, & this->ch ); } else { r = FMOD_System_PlaySound( parent->sys, FMOD_CHANNEL_REUSE, sound, 0, & this->ch ); } FMOD_ERRCHECK(r); FMOD_Channel_SetVolume(ch, default_volume * vol ); }
void Audio::playBGM(const QString &filename) { FMOD_RESULT result = FMOD_System_CreateStream(System, filename.toLocal8Bit(), FMOD_LOOP_NORMAL, NULL, &BGM); if (result == FMOD_OK) { FMOD_Sound_SetLoopCount(BGM, -1); FMOD_System_PlaySound(System, FMOD_CHANNEL_FREE, BGM, false, &BGMChannel); FMOD_Channel_SetVolume(BGMChannel, Config.BGMVolume); FMOD_System_Update(System); } }
boolean I_PlaySong(INT32 handle, boolean looping) { if (1337 == handle) { midimode = true; if (looping) FMR(FMOD_Sound_SetMode(music_stream, FMOD_LOOP_NORMAL)); FMR(FMOD_System_PlaySound(fsys, FMOD_CHANNEL_FREE, music_stream, false, &music_channel)); FMR_MUSIC(FMOD_Channel_SetVolume(music_channel, midi_volume / 31.0)); FMR_MUSIC(FMOD_Channel_SetPriority(music_channel, 0)); } return true; }
bool Sound::setVolume(float value) { if (this->_channel) { if (FMOD_Channel_SetVolume(this->_channel, value)) { //std::cerr << "Error on setting volume sound " + this->_name << std::endl; return (false); } return (true); } return (false); }
void FMODSound::play(void) { if (this->_channel) { FMOD_Channel_GetPaused(this->_channel, &(this->_tmp)); } if (this->_tmp == true) FMOD_Channel_SetPaused(this->_channel, false); else FMOD_System_PlaySound(this->_system, FMOD_CHANNEL_FREE, this->_sound, 0, &(this->_channel)); FMOD_Channel_SetVolume(this->_channel, this->_volume); }
void sound_play(eSound snd, float vol, float pan, float freq) { static Sound* s; if (!s) s = &((Data*)SDLazy_GetData())->sound; FMOD_System_PlaySound(s->system, FMOD_CHANNEL_FREE, s->mp3[snd], 0, &s->chan); FMOD_Channel_SetVolume(s->chan, vol); FMOD_Channel_SetPan(s->chan, pan); FMOD_Channel_SetFrequency(s->chan, freq); FMOD_System_Update(s->system); }
void ModuleIrisAudio::FadeBgmThreadProc(int duration){ bgmIsFading = true; int time = duration; while (time >= 0){ float v; FMOD_Channel_SetPaused(bgmChannel, true); FMOD_Channel_GetVolume(bgmChannel, &v); FMOD_Channel_SetVolume(bgmChannel, v - v / (duration / 1000)); time -= 1000; FMOD_Channel_SetPaused(bgmChannel, false); Sleep(1000); } FMOD_Channel_Stop(bgmChannel); bgmIsFading = false; }
bool Audio::SetVolume(std::string filename, float level) { Sample *sample = FindSample(filename); //***BUG if (!sample) return false; if (sample->sample != NULL) { try { FMOD_Channel_SetVolume(sample->channel,level); } catch (...) { return false; } } return true; }
SoundID AudioPlayer::playSound( ResID id , float volume , bool beLoop ) { SoundRes* res = getSound( id ); if ( res == NULL ) return ERROR_SOUND_ID; FMOD_CHANNEL* channel; FMOD_System_PlaySound( mFmodSys , FMOD_CHANNEL_FREE , res->sound , false , &channel ); FMOD_Channel_SetVolume( channel , volume * res->volume * mSoundVolume ); FMOD_Channel_SetCallback( channel ,ChannelCallBack ); if ( beLoop ) FMOD_Channel_SetMode( channel ,FMOD_LOOP_NORMAL ); return registerChannel( channel ); }
// seems to never be called on an invalid channel (calls I_SoundIsPlaying first?) // so I'm not gonna worry about it. void I_UpdateSoundParams(INT32 handle, UINT8 vol, UINT8 sep, UINT8 pitch) { FMOD_CHANNEL *chan; FMOD_SOUND *sound; float frequency; FMR(FMOD_System_GetChannel(fsys, handle, &chan)); FMR(FMOD_Channel_SetVolume(chan, (vol / 255.0) * (sfx_volume / 31.0))); FMR(FMOD_Channel_SetPan(chan, (sep - 128) / 127.0)); FMR(FMOD_Channel_GetCurrentSound(chan, &sound)); FMR(FMOD_Sound_GetDefaults(sound, &frequency, NULL, NULL, NULL)); FMR(FMOD_Channel_SetFrequency(chan, (pitch / 128.0) * frequency)); //FMR(FMOD_Channel_SetPriority(chan, 1 + ((0xff-vol)>>1))); // automatic priority 1 - 128 based on volume (priority 0 is music) }
bool ClientActionToneMelody::runAction() { FMOD_RESULT result; if (!system) { channel = 0; result = FMOD_System_Create(&system); ERRCHECK(result); FMOD_System_SetDSPBufferSize(system, 64, 1); result = FMOD_System_Init(system, 2, FMOD_INIT_STREAM_FROM_UPDATE | FMOD_INIT_MIX_FROM_UPDATE, NULL); ERRCHECK(result); result = FMOD_System_CreateDSPByType(system, FMOD_DSP_TYPE_OSCILLATOR, &dsp); ERRCHECK(result); } if (channel) { result = FMOD_Channel_Stop(channel); ERRCHECK(result); channel = 0; } if (tone_frequency) { result = FMOD_DSP_SetParameterFloat(dsp, FMOD_DSP_OSCILLATOR_RATE, (float) tone_frequency); ERRCHECK(result); result = FMOD_System_PlayDSP(system, dsp, 0, true, &channel); ERRCHECK(result); result = FMOD_Channel_SetVolume(channel, 1.0f); ERRCHECK(result); result = FMOD_DSP_SetParameterInt(dsp,FMOD_DSP_OSCILLATOR_TYPE, 1); ERRCHECK(result); StartMelodyTone(settings->value("MELODY")); updateTimer->start(); settings->insert("ACTIVE", "1"); } else { updateTimer->stop(); periodicToneTimer->stop(); prog_led_tone_control = false; tone_state = false; tone_periodic = false; tone_period = 0; settings->insert("ACTIVE", "0"); } return true; }
void Audio::jouerSon(audio_t son, bool boucle) throw(Audio::Exc_Son) { if(boucle) FMOD_Sound_SetLoopCount(son, -1); else FMOD_Sound_SetLoopCount(son, 0); FMOD_CHANNEL *c = 0; resultat = FMOD_System_PlaySound(_systeme, FMOD_CHANNEL_FREE, son, false, &c); erreur(resultat, 7); int nb; FMOD_Channel_GetIndex(c, &nb); _canaux[nb] = c; FMOD_Channel_SetCallback(c, &sonStoppe); FMOD_Channel_SetVolume(c, Parametres::volumeEffets()); }
void Sound::Play(bool bLoop) { // Check if we have a sound loaded if (!mLoaded) { return; } // Stop any previous sound first Stop(); // Check if we are already playing FMOD_System_PlaySound(FMODBridge::Get()->FMODSystem(), FMOD_CHANNEL_FREE, mpSound, true, &mpChannel); FMOD_Channel_SetLoopCount(mpChannel, bLoop ? -1 : 0); FMOD_Channel_SetVolume(mpChannel, mVolume); FMOD_Channel_SetPaused(mpChannel, false); }
void Audio::jouerMusique() throw(Audio::Exc_Son) { if(_canalMusique) { FMOD_BOOL pause; FMOD_Channel_GetPaused(_canalMusique, &pause); if(!pause) return; } resultat = FMOD_System_PlaySound(_systeme, FMOD_CHANNEL_FREE, _musique, false, &_canalMusique); erreur(resultat, 8); int nb; FMOD_Channel_GetIndex(_canalMusique, &nb); _canaux[nb] = _canalMusique; FMOD_Channel_SetVolume(_canalMusique, Parametres::volumeMusique()); }
void QSPCallBacks::SetOverallVolume(float coeff) { QSPSound *snd; FMOD_BOOL playing = FALSE; if (coeff < 0.0) coeff = 0.0; else if (coeff > 1.0) coeff = 1.0; m_volumeCoeff = coeff; for (QSPSounds::iterator i = m_sounds.begin(); i != m_sounds.end(); ++i) { snd = (QSPSound *)&i->second; FMOD_Channel_IsPlaying(snd->Channel, &playing); if (playing) FMOD_Channel_SetVolume(snd->Channel, (float)(m_volumeCoeff * snd->Volume) / 100); } }
void Sound::AddToVolume(float fVolume) { // Check if we have a sound loaded if (!mLoaded) { return; } // Cache the volume mVolume += fVolume; if (mVolume> 1.0f) mVolume = 1.0f; else if (mVolume <0.0f) mVolume = 0.0f; // Check if we have a valid channel if (0 != mpChannel) { FMOD_Channel_SetVolume(mpChannel, mVolume); } }
void CSound::SetVolume(float fVolume) { // Check if we have a sound loaded if (!mLoaded) { return; } // Cache the volume mVolume = fVolume; if (mVolume > 1.0f) mVolume = 1.0f; else if (mVolume < 0.0f) mVolume = 0.0f; #if __ENABLE_CFMOD // Check if we have a valid channel if (0 != mpChannel) { FMOD_Channel_SetVolume(mpChannel, mVolume); } #endif }
void MOD_Update (void) { if(SND_Initialised == false || SND_MusicChannel.inuse == false) return; FMOD_System_Update(fmod_system); SND_MusicChannel.volume = bgmvolume.value; if(SND_MusicChannel.volume < 0.0f) SND_MusicChannel.volume = 0.0f; if(SND_MusicChannel.volume > 1.0f) SND_MusicChannel.volume = 1.0f; FMOD_Channel_SetVolume(SND_MusicChannel.channel, SND_MusicChannel.volume); if(SND_MusicChannel.volume == 0.0f | cl.paused == true) MOD_Pause(); else MOD_Resume(); }
void whitgl_loop_volume(int id, float volume) { int index = -1; int i; for(i=0; i<num_sounds; i++) { if(sounds[i].id == id) { index = i; continue; } } if(index == -1) { WHITGL_LOG("ERR Cannot find sound %d", id); return; } FMOD_RESULT result = FMOD_Channel_SetVolume(sounds[index].channel, volume); _whitgl_sound_errcheck("FMOD_Channel_SetVolume", result); }
/* --------------------------------------- 设置音量 --------------------------------------- */ static bool_t iXMM_FMOD_set_volume ( __CR_IO__ iXMMEDIA* that, __CR_IN__ sint_t percent ) { float vols; iXMM_FMOD* real; FMOD_RESULT result; real = (iXMM_FMOD*)that; if (percent < 0) percent = 0; else if (percent > 100) percent = 100; vols = ((float)percent) / 100.0f; result = FMOD_Channel_SetVolume(real->m_chn, vols); if (result != FMOD_OK) return (FALSE); that->__volume__ = percent; return (TRUE); }
void whitgl_loop_add(int id, const char* filename) { WHITGL_LOG("Adding loop: %s", filename); if(num_sounds >= WHITGL_SOUND_MAX) { WHITGL_LOG("ERR Too many sounds"); return; } sounds[num_sounds].id = id; FMOD_RESULT result = FMOD_System_CreateSound(fmodSystem, filename, FMOD_HARDWARE | FMOD_2D | FMOD_LOOP_NORMAL, 0, &sounds[num_sounds].sound); _whitgl_sound_errcheck("FMOD_System_CreateSound", result); result = FMOD_System_PlaySound(fmodSystem, FMOD_CHANNEL_FREE, sounds[num_sounds].sound, true, &sounds[num_sounds].channel); _whitgl_sound_errcheck("FMOD_System_PlaySound", result); result = FMOD_Channel_SetVolume(sounds[num_sounds].channel, 0); _whitgl_sound_errcheck("FMOD_Channel_SetVolume", result); result = FMOD_Channel_SetPaused(sounds[num_sounds].channel, false); _whitgl_sound_errcheck("FMOD_Channel_SetPaused", result); num_sounds++; }
// ---------------------------------------------------------------------------- void ofSoundPlayer::play(){ // if it's a looping sound, we should try to kill it, no? // or else people will have orphan channels that are looping if (bLoop == true){ FMOD_Channel_Stop(channel); } // if the sound is not set to multiplay, then stop the current, // before we start another if (!bMultiPlay){ FMOD_Channel_Stop(channel); } FMOD_System_PlaySound(sys, FMOD_CHANNEL_FREE, sound, bPaused, &channel); FMOD_Channel_GetFrequency(channel, &internalFreq); FMOD_Channel_SetVolume(channel,volume); FMOD_Channel_SetPan(channel,pan); FMOD_Channel_SetFrequency(channel, internalFreq * speed); FMOD_Channel_SetMode(channel, (bLoop == true) ? FMOD_LOOP_NORMAL : FMOD_LOOP_OFF); }
void update_sound(void) { int i; int vol, pan; if(!sound_is_on)return; for(i=0;i<MAX_SOUNDS_PLAYING;i++) { if(sound_data[i].used) { FMOD_BOOL is_playing; FMOD_Channel_IsPlaying(sound_data[i].voice_num, &is_playing); if(is_playing==FALSE) { FMOD_Channel_Stop(sound_data[i].voice_num); sound_data[i].used=0; } else { if(!sound_data[i].lower_at_dist) { vol = sound_data[i].vol; pan = 128; } else calc_sound_prop(sound_data[i].x,sound_data[i].y,&vol, &pan, sound_info[sound_data[i].sound_num].volume); FMOD_Channel_SetVolume(sound_data[i].voice_num, ((float)vol)/256); FMOD_Channel_SetPan(sound_data[i].voice_num, pan); } } } }
void Game::loadRessources() { blockImage.LoadFromFile(BLOCK_IMG); bgImage.LoadFromFile(BG_IMG); gameOverImage.LoadFromFile(GAME_OVER_IMG); digital.LoadFromFile(DIGITAL_FONT); vador.LoadFromFile(VADOR_FONT); myriad.LoadFromFile(MYRIAD_FONT); FMOD_System_Create(&system); FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL); FMOD_System_CreateSound(system, MOVE_SOUND.c_str(), FMOD_DEFAULT, 0, &move); FMOD_System_CreateSound(system, HOLD_SOUND.c_str(), FMOD_DEFAULT, 0, &hold); FMOD_System_CreateSound(system, DROP_SOUND.c_str(), FMOD_DEFAULT, 0, &drop); FMOD_System_CreateSound(system, DELETE_SOUND.c_str(), FMOD_DEFAULT, 0, &deletion); FMOD_System_CreateSound(system, MARATHON_MUSIC.c_str(), FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_LOOP_NORMAL, 0, &marathonMusic); FMOD_System_CreateSound(system, SPRINT_MUSIC.c_str(), FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_LOOP_NORMAL, 0, &sprintMusic); FMOD_System_CreateSound(system, ULTRA_MUSIC.c_str(), FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_LOOP_NORMAL, 0, &ultraMusic); FMOD_Channel_SetVolume(musicChannel, 0.5); }