bool ModuleIrisAudio::MePlay(wstring filePath, int volume, int rate){
string sfilepath = WStringToString(filePath);
const char* fpath = sfilepath.c_str();
if (channels == 0){
if (meChannel != NULL){
BOOL isPlaying;
FMOD_Channel_IsPlaying(meChannel, &isPlaying);
if (isPlaying)
FMOD_Channel_Stop(meChannel);
}
}
FMOD_RESULT result;
result = FMOD_System_CreateStream(fmodSystem, fpath, FMOD_DEFAULT, 0, &me);
if (result != FMOD_OK)
return false;
result = FMOD_System_PlaySound(fmodSystem, FMOD_CHANNEL_FREE, me, true, &meChannel);
if (result != FMOD_OK)
return false;
FMOD_Channel_SetMode(meChannel, FMOD_LOOP_NORMAL);
FMOD_Channel_SetVolume(meChannel, volume / 100.0f);
float frequancy;
FMOD_Channel_GetFrequency(meChannel, &frequancy);
FMOD_Channel_SetFrequency(meChannel, frequancy * (rate / 100.0));
FMOD_Channel_SetPaused(meChannel, FALSE);
return true;
}
// ----------------------------------------------------------------------------
void ofxSoundPlayerFMOD::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);
//fmod update() should be called every frame - according to the docs.
//we have been using fmod without calling it at all which resulted in channels not being able
//to be reused. we should have some sort of global update function but putting it here
//solves the channel bug
FMOD_System_Update(sys);
}
void AudioManager::Play( const AudioManager::AudioType Type,
const string& ID,
const float Volume,
const float Pitch,
const float Pan,
const int32_t LoopCount,
const int32_t Priority,
const FMOD_CHANNELINDEX ChannelIndex )
{
// Create local variables.
float Frequency = Null;
FMOD_CHANNEL* Channel = nullptr;
unordered_map< string, SoundData >::iterator AudioMapIterator;
// Check arguments.
if( Type == MaxAudioTypes )
throw exception();
// Playback specified audio sample or stream.
if( Initialized )
{
AudioMapIterator = AudioMaps[ Type ].Instance.find( ID );
if( AudioMapIterator == AudioMaps[ Type ].Instance.end() )
throw exception();
if( FMOD_System_PlaySound( SystemInstance, ChannelIndex, AudioMapIterator->second.Instance, true, &Channel ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetChannelGroup( Channel, AudioMapIterator->second.Group ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetLoopCount( Channel, LoopCount ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetPriority( Channel, Priority ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetPan( Channel, Pan ) != FMOD_OK )
throw exception();
if( FMOD_Channel_GetFrequency( Channel, &Frequency ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetFrequency( Channel, ( Frequency * Pitch ) ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetVolume( Channel, Volume ) != FMOD_OK )
throw exception();
if( FMOD_Channel_SetPaused( Channel, false ) != FMOD_OK )
throw exception();
}
}
void AudioPlayer::setSoundFreq( SoundID sID , float freqFactor )
{
if ( sID == ERROR_SOUND_ID )
return;
Channel* channel = getChannel( sID );
if ( !channel )
return;
float freq;
FMOD_Channel_GetFrequency( channel , &freq );
FMOD_Channel_SetFrequency( channel , freqFactor * freq );
}
void PlayStereoFrequency( short player, short which, short freq )
{
if( soundOn )
{
float oldFreq;
FMOD_System_PlaySound( fmodSystem, FMOD_CHANNEL_FREE, sound[which], true, &soundChannel[player] );
// SetPan pans the sound from -1 (full left) to 1 (full right).
// which means player 0 should be -1 and player 1 should be 1.
// Except hard panning sounds kind of bad so player 0 should be
// -0.75 and player 1 should be 0.75.
if( playerWindowVisible[1] ) {
FMOD_Channel_SetPan( soundChannel[player], -0.75f + 1.5f * player );
} else {
FMOD_Channel_SetPan( soundChannel[player], 0.0f );
}
FMOD_Channel_GetFrequency( soundChannel[player], &oldFreq );
FMOD_Channel_SetFrequency( soundChannel[player], oldFreq * (16 + freq)/ 16 );
FMOD_Channel_SetPaused( soundChannel[player], false );
}
}
SoundID AudioPlayer::playSound( ResID id , float volume , bool beLoop , float freqFactor )
{
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 );
float freq;
FMOD_Channel_GetFrequency( channel , &freq );
FMOD_Channel_SetFrequency( channel , freqFactor * freq );
if ( beLoop )
FMOD_Channel_SetMode( channel ,FMOD_LOOP_NORMAL );
return registerChannel( channel );
}
// ----------------------------------------------------------------------------
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);
}
int main(int argc, char *argv[])
{
FMOD_SYSTEM *system;
FMOD_CHANNEL *channel = 0;
FMOD_DSP *dsp = 0;
FMOD_RESULT result;
int key;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
getch();
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
/*
Create DSP units for each type of noise we want.
*/
result = FMOD_System_CreateDSPByType(system, FMOD_DSP_TYPE_OSCILLATOR, &dsp);
ERRCHECK(result);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_RATE, 440.0f);
ERRCHECK(result);
printf("======================================================================\n");
printf("GenerateTone Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("======================================================================\n\n");
printf("\n");
printf("Press '1' to play a sine wave\n");
printf("Press '2' to play a square wave\n");
printf("Press '3' to play a triangle wave\n");
printf("Press '4' to play a saw wave\n");
printf("Press '5' to play a white noise\n");
printf("Press 's' to stop channel\n");
printf("\n");
printf("Press 'v'/'V' to change channel volume\n");
printf("Press 'f'/'F' to change channel frequency\n");
printf("Press '['/']' to change channel pan\n");
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case '1' :
{
result = FMOD_System_PlayDSP(system, FMOD_CHANNEL_REUSE, dsp, TRUE, &channel);
FMOD_Channel_SetVolume(channel, 0.5f);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_TYPE, 0);
ERRCHECK(result);
FMOD_Channel_SetPaused(channel, FALSE);
break;
}
case '2' :
{
result = FMOD_System_PlayDSP(system, FMOD_CHANNEL_REUSE, dsp, TRUE, &channel);
FMOD_Channel_SetVolume(channel, 0.125f);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_TYPE, 1);
ERRCHECK(result);
FMOD_Channel_SetPaused(channel, FALSE);
break;
}
case '3' :
{
result = FMOD_System_PlayDSP(system, FMOD_CHANNEL_REUSE, dsp, TRUE, &channel);
FMOD_Channel_SetVolume(channel, 0.5f);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_TYPE, 2);
ERRCHECK(result);
FMOD_Channel_SetPaused(channel, FALSE);
break;
}
case '4' :
{
result = FMOD_System_PlayDSP(system, FMOD_CHANNEL_REUSE, dsp, TRUE, &channel);
FMOD_Channel_SetVolume(channel, 0.125f);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_TYPE, 4);
ERRCHECK(result);
FMOD_Channel_SetPaused(channel, FALSE);
break;
}
case '5' :
{
result = FMOD_System_PlayDSP(system, FMOD_CHANNEL_REUSE, dsp, TRUE, &channel);
FMOD_Channel_SetVolume(channel, 0.25f);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_OSCILLATOR_TYPE, 5);
ERRCHECK(result);
FMOD_Channel_SetPaused(channel, FALSE);
break;
}
case 's' :
{
FMOD_Channel_Stop(channel);
break;
}
case 'v' :
{
float volume;
FMOD_Channel_GetVolume(channel, &volume);
volume -= 0.1f;
FMOD_Channel_SetVolume(channel, volume);
break;
}
case 'V' :
{
float volume;
FMOD_Channel_GetVolume(channel, &volume);
volume += 0.1f;
FMOD_Channel_SetVolume(channel, volume);
break;
}
case 'f' :
{
float frequency;
FMOD_Channel_GetFrequency(channel, &frequency);
frequency -= 500.0f;
FMOD_Channel_SetFrequency(channel, frequency);
break;
}
case 'F' :
{
float frequency;
FMOD_Channel_GetFrequency(channel, &frequency);
frequency += 500.0f;
FMOD_Channel_SetFrequency(channel, frequency);
break;
}
case '[' :
{
float pan;
FMOD_Channel_GetPan(channel, &pan);
pan -= 0.1f;
FMOD_Channel_SetPan(channel, pan);
break;
}
case ']' :
{
float pan;
FMOD_Channel_GetPan(channel, &pan);
pan += 0.1f;
FMOD_Channel_SetPan(channel, pan);
break;
}
}
}
FMOD_System_Update(system);
{
float frequency = 0, volume = 0, pan = 0;
int playing = FALSE;
if (channel)
{
FMOD_Channel_GetFrequency(channel, &frequency);
FMOD_Channel_GetVolume(channel, &volume);
FMOD_Channel_GetPan(channel, &pan);
FMOD_Channel_IsPlaying(channel, &playing);
}
printf("Channel %s : Frequency %.1f Volume %.1f Pan %.1f \r", playing ? "playing" : "stopped", frequency, volume, pan);
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_DSP_Release(dsp);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
float sound::speed() const
{
float current = 1;
FMOD_Channel_GetFrequency(_chan, ¤t);
return current / _origFreq;
}
sound::sound(FMOD_CHANNEL *chan):
_chan(chan),
_origFreq(1)
{
FMOD_Channel_GetFrequency(_chan, &_origFreq);
}
FMOD_CHANNEL *queue_next_sound(int outputrate, FMOD_CHANNEL *playingchannel, int newindex, int slot)
{
FMOD_RESULT result;
FMOD_CHANNEL *newchannel;
FMOD_SOUND *newsound;
#ifdef USE_STREAMS /* Create a new stream */
FMOD_CREATESOUNDEXINFO info;
memset(&info, 0, sizeof(FMOD_CREATESOUNDEXINFO));
info.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
info.suggestedsoundtype = FMOD_SOUND_TYPE_OGGVORBIS;
result = FMOD_System_CreateStream(gSystem, soundname[newindex], FMOD_IGNORETAGS | FMOD_LOWMEM, &info, &sound[slot]);
ERRCHECK(result);
newsound = sound[slot];
#else /* Use an existing sound that was passed into us */
newsound = sound[newindex];
#endif
result = FMOD_System_PlaySound(gSystem, FMOD_CHANNEL_FREE, newsound, 1, &newchannel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(newchannel, 1,1,1,1,1,1,1,1);
ERRCHECK(result);
if (playingchannel)
{
unsigned int hi = 0, lo = 0, sound_length;
float sound_frequency;
FMOD_SOUND *playingsound;
/*
Get the start time of the playing channel.
*/
result = FMOD_Channel_GetDelay(playingchannel, FMOD_DELAYTYPE_DSPCLOCK_START, &hi, &lo);
ERRCHECK(result);
printf("playing sound started at %d\n", lo);
/*
Grab the length of the playing sound, and its frequency, so we can caluate where to place the new sound on the time line.
*/
result = FMOD_Channel_GetCurrentSound(playingchannel, &playingsound);
ERRCHECK(result);
result = FMOD_Sound_GetLength(playingsound, &sound_length, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
result = FMOD_Channel_GetFrequency(playingchannel, &sound_frequency);
ERRCHECK(result);
/*
Now calculate the length of the sound in 'output samples'.
Ie if a 44khz sound is 22050 samples long, and the output rate is 48khz, then we want to delay by 24000 output samples.
*/
sound_length *= outputrate;
sound_length /= (int)sound_frequency;
FMOD_64BIT_ADD(hi, lo, 0, sound_length); /* Add output rate adjusted sound length, to the clock value of the sound that is currently playing */
result = FMOD_Channel_SetDelay(newchannel, FMOD_DELAYTYPE_DSPCLOCK_START, hi, lo); /* Set the delay of the new sound to the end of the old sound */
ERRCHECK(result);
}
{
unsigned int hi = 0, lo = 0;
float val, variation;
/*
Randomize pitch/volume to make it sound more realistic / random.
*/
FMOD_Channel_GetFrequency(newchannel, &val);
variation = (((float)(rand()%10000) / 5000.0f) - 1.0f); /* -1.0 to +1.0 */
val *= (1.0f + (variation * 0.02f)); /* @22khz, range fluctuates from 21509 to 22491 */
FMOD_Channel_SetFrequency(newchannel, val);
FMOD_Channel_GetVolume(newchannel, &val);
variation = ((float)(rand()%10000) / 10000.0f); /* 0.0 to 1.0 */
val *= (1.0f - (variation * 0.2f)); /* 0.8 to 1.0 */
FMOD_Channel_SetVolume(newchannel, val);
FMOD_Channel_GetDelay(newchannel, FMOD_DELAYTYPE_DSPCLOCK_START, &hi, &lo);
printf("new sound to start at %d (slot %d)\n", lo, slot);
}
result = FMOD_Channel_SetPaused(newchannel, FALSE);
ERRCHECK(result);
return newchannel;
}
FMOD_RESULT bmx_FMOD_Channel_GetFrequency(MAX_FMOD_CHANNEL *channel, float *frequency) {
return FMOD_Channel_GetFrequency(channel->channel, frequency);
}
