void AudioVisualizerApp::playAudio( const fs::path& file )
{
FMOD_RESULT err;
// ignore if this is not a file
if( file.empty() || !fs::is_regular_file( file ) )
return;
// if audio is already playing, stop it first
stopAudio();
// stream the audio
err = mFMODSystem->createStream( file.string().c_str(), FMOD_SOFTWARE, NULL, &mFMODSound );
err = mFMODSystem->playSound( FMOD_CHANNEL_FREE, mFMODSound, false, &mFMODChannel );
// we want to be notified of channel events
err = mFMODChannel->setCallback( channelCallback );
// keep track of the audio file
mAudioPath = file;
mIsAudioPlaying = true;
//
console() << "Now playing:" << mAudioPath.filename() << std::endl;
}
void FMOD_System::CreateSounds( const SoundFilenameMap& soundFilenames )
{
auto isPresent = [=]( const std::string& key ) -> bool
{
return ( soundFilenames.find( key ) != soundFilenames.end() ) ? true : false;
};
if( isPresent( "bgmusic" ) )
{
ErrorCheck( system->createStream( soundFilenames.at("bgmusic").c_str(), FMOD_LOOP_NORMAL | FMOD_CREATESTREAM,
nullptr, &bgmusic ) );
bgmusic->setDefaults( 44100, 0.025f, 0.f, 128 );
}
if( isPresent( "jet" ) )
{
ErrorCheck( system->createSound( soundFilenames.at( "jet" ).c_str(), FMOD_3D, nullptr, &jet ) );
jet->setDefaults( 44100, 0.75f, 0.f, 128 );
}
if( isPresent( "vent" ) )
{
ErrorCheck( system->createSound( soundFilenames.at( "vent" ).c_str(), FMOD_3D | FMOD_LOOP_NORMAL,
nullptr, &ventSound ) );
ventSound->setDefaults( 44100, 0.3f, 0.f, 128 );
}
if( isPresent( "collision" ) )
{
ErrorCheck( system->createSound( soundFilenames.at( "collision" ).c_str(), FMOD_3D, nullptr, &collision ) );
collision->setDefaults( 44100, 5.f, 0.f, 128 );
}
if( isPresent( "roll" ) )
{
ErrorCheck( system->createSound( soundFilenames.at( "roll" ).c_str(), FMOD_3D, nullptr, &roll ) );
roll->setDefaults( 44100, 2.f, 0.f, 128 );
}
}
void cinderFFmpegApp::setup()
{
m_Font = ci::Font("Consolas", 48);
setupGui();
gl::enableAlphaBlending();
std::shared_ptr<_2RealFFmpegWrapper::FFmpegWrapper> testFile = std::shared_ptr<_2RealFFmpegWrapper::FFmpegWrapper>(new _2RealFFmpegWrapper::FFmpegWrapper());
testFile->dumpFFmpegInfo();
//if(testFile->open(".\\data\\morph.avi"))
if(testFile->open("d:\\vjing\\Wildlife.wmv"))
{
m_Players.push_back(testFile);
m_VideoTextures.push_back(gl::Texture());
m_Players.back()->play();
}
m_dLastTime = 0;
m_iCurrentVideo = 0;
m_fSpeed = 1;
m_iLoopMode = _2RealFFmpegWrapper::eLoop;
m_iTilesDivisor = 1;
m_fSeekPos = m_fOldSeekPos = 0;
//setup fmod
FMOD::System_Create(&m_pSystem);
m_pSystem->init(32, FMOD_INIT_NORMAL, 0);
memset(&createsoundexinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
createsoundexinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO); /* required. */
createsoundexinfo.decodebuffersize = 1024; /* Chunk size of stream update in samples. This will be the amount of data passed to the user callback. */
createsoundexinfo.numchannels = 2; /* Number of channels in the sound. */
createsoundexinfo.length = -1; /* Length of PCM data in bytes of whole song. -1 = infinite. */
createsoundexinfo.defaultfrequency = (int)44100; /* Default playback rate of sound. */
createsoundexinfo.format = FMOD_SOUND_FORMAT_PCM16; /* Data format of sound. */
createsoundexinfo.pcmreadcallback = pcmreadcallback; /* User callback for reading. */
result = m_pSystem->createStream(0, FMOD_2D | FMOD_OPENUSER | FMOD_LOOP_OFF, &createsoundexinfo, &m_pSound);
result = m_pSystem->playSound(FMOD_CHANNEL_FREE, m_pSound, 0, &m_pChannel);
//std::shared_ptr<audio::Callback<cinderFFmpegApp,unsigned short>> audioCallback = audio::createCallback( this, &cinderFFmpegApp::audioCallback );
//audio::Output::play( audioCallback );
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int version;
HANDLE threadhandle;
InitializeCriticalSection(&gCrit);
threadhandle = (HANDLE)_beginthreadex(NULL, 0, ProcessQueue, 0, 0, 0);
if (!threadhandle)
{
printf("Failed to create file thread.\n");
return 0;
}
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->setStreamBufferSize(32768, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
result = system->setFileSystem(myopen, myclose, myread, myseek, myasyncread, myasynccancel, 2048);
ERRCHECK(result);
printf("====================================================================\n");
printf("Stream IO Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("====================================================================\n");
printf("\n");
printf("\n");
printf("====================== CALLING CREATESOUND ON MP3 =======================\n");
result = system->createStream("../media/wave.mp3", FMOD_SOFTWARE | FMOD_LOOP_NORMAL | FMOD_2D | FMOD_IGNORETAGS, 0, &sound);
ERRCHECK(result);
printf("====================== CALLING PLAYSOUND ON MP3 =======================\n");
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (sound)
{
FMOD_OPENSTATE openstate;
bool starving;
sound->getOpenState(&openstate, 0, &starving, 0);
if (starving)
{
printf("Starving\n");
result = channel->setMute(true);
}
else
{
result = channel->setMute(false);
ERRCHECK(result);
}
}
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
result = sound->release();
if (result == FMOD_OK)
{
sound = 0;
printf("Released sound.\n");
}
break;
}
}
}
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
if (sound)
{
result = sound->release();
ERRCHECK(result);
}
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
gThreadQuit = true;
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD_RESULT result;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createStream("../media/wave.mp3", FMOD_OPENONLY | FMOD_ACCURATETIME, 0, &sound);
ERRCHECK(result);
printf("==========================================================================\n");
printf("Offline Decoding Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("==========================================================================\n");
printf("\n");
printf("This program will open wave.mp3 and decode it into wave.raw using the\n");
printf("Sound::readData function.\n");
printf("\n");
/*
Decode the sound and write it to a .raw file.
*/
{
void *data;
unsigned int length = 0, read;
unsigned int bytesread;
FILE *outfp;
#define CHUNKSIZE 4096
result = sound->getLength(&length, FMOD_TIMEUNIT_PCMBYTES);
ERRCHECK(result);
outfp = fopen("output.raw", "wb");
if (!outfp)
{
printf("Error! Could not open output.raw output file.\n");
return 0;
}
data = malloc(CHUNKSIZE);
if (!data)
{
printf("Error! Failed to allocate %d bytes.\n", CHUNKSIZE);
return 0;
}
bytesread = 0;
do
{
result = sound->readData((char *)data, CHUNKSIZE, &read);
fwrite((char *)data, read, 1, outfp);
bytesread += read;
printf("writing %d bytes of %d to output.raw\r", bytesread, length);
}
while (result == FMOD_OK && read == CHUNKSIZE);
/*
Loop terminates when either
1. the read function returns an error. (ie FMOD_ERR_FILE_EOF etc).
2. the amount requested was different to the amount returned. (somehow got an EOF without the file error, maybe a non stream file format like mod/s3m/xm/it/midi).
If 'bytesread' is bigger than 'length' then it just means that FMOD miscalculated the size,
but this will not usually happen if FMOD_ACCURATETIME is used. (this will give the correct length for VBR formats)
*/
printf("\n");
if (outfp)
{
fclose(outfp);
}
}
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->setFileSystem(myopen, myclose, myread, myseek, 0, 0, 2048);
ERRCHECK(result);
result = system->createStream("../media/wave.mp3", FMOD_HARDWARE | FMOD_LOOP_NORMAL | FMOD_2D, 0, &sound);
ERRCHECK(result);
printf("========================================================================\n");
printf("File Callbacks Example. Copyright (c) Firelight Technologies 2004-2015.\n");
printf("========================================================================\n");
printf("\n");
printf("Press space to pause, Esc to quit\n");
printf("\n");
/*
Play the sound.
*/
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
}
}
system->update();
if (channel)
{
unsigned int ms;
unsigned int lenms;
bool playing;
bool paused;
channel->isPlaying(&playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = sound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
FMOD_CREATESOUNDEXINFO createsoundexinfo;
unsigned int version, decodesound_lengthbytes = 0;
int decodesound_channels;
float decodesound_rate;
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
InitializeCriticalSection(&decodecrit);
/*
First create the 'decoder sound'. Note it is a stream that does not initially read any data, because FMOD_OPENONLY has been specified.
We could use createSound instead of createStream but that would allocate memory for the whole sound which is a waste.
*/
result = system->createStream("../media/wave.mp3", FMOD_OPENONLY | FMOD_LOOP_NORMAL | FMOD_LOWMEM | FMOD_CREATESTREAM, 0, &decodesound);
ERRCHECK(result);
result = decodesound->getLength(&decodesound_lengthbytes, FMOD_TIMEUNIT_PCMBYTES);
ERRCHECK(result);
result = decodesound->getFormat(0, 0, &decodesound_channels, 0);
ERRCHECK(result);
result = decodesound->getDefaults(&decodesound_rate, 0, 0, 0);
ERRCHECK(result);
/*
Now create a user created PCM stream that we will feed data into, and play.
*/
memset(&createsoundexinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
createsoundexinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO); /* required. */
createsoundexinfo.decodebuffersize = 44100; /* Chunk size of stream update in samples. This will be the amount of data passed to the user callback. */
createsoundexinfo.numchannels = decodesound_channels; /* Number of channels in the sound. */
createsoundexinfo.length = decodesound_lengthbytes; /* Length of PCM data in bytes of whole song. -1 = infinite. */
createsoundexinfo.defaultfrequency = (int)decodesound_rate; /* Default playback rate of sound. */
createsoundexinfo.format = FMOD_SOUND_FORMAT_PCM16; /* Data format of sound. */
createsoundexinfo.pcmreadcallback = pcmreadcallback; /* User callback for reading. */
createsoundexinfo.pcmsetposcallback = pcmsetposcallback; /* User callback for seeking. */
result = system->createStream(0, FMOD_2D | FMOD_OPENUSER | FMOD_LOOP_NORMAL, &createsoundexinfo, &sound);
ERRCHECK(result);
printf("============================================================================\n");
printf("Manual Decode example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("============================================================================\n");
printf("Sound played here decoded in realtime by the user with a 'decoder sound' \n");
printf("The mp3 is created as a stream opened with FMOD_OPENONLY. This is the \n");
printf("'decoder sound'. The playback sound is a 16bit PCM FMOD_OPENUSER created \n");
printf("sound with a pcm read callback. When the callback happens, we call readData\n");
printf("on the decoder sound and use the pcmreadcallback data pointer as the parameter.\n");
printf("============================================================================\n");
printf("\n");
printf("Press space to pause, Esc to quit\n");
printf("Press '<' to rewind 1 second.\n");
printf("Press '>' to fast forward 1 second.\n");
printf("\n");
/*
Play the sound.
*/
result = system->playSound(FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
case '<' :
{
unsigned int position;
channel->getPosition(&position, FMOD_TIMEUNIT_MS);
if (position >= 1000)
{
position -= 1000;
}
channel->setPosition(position, FMOD_TIMEUNIT_MS);
break;
}
case '>' :
{
unsigned int position;
channel->getPosition(&position, FMOD_TIMEUNIT_MS);
position += 1000;
channel->setPosition(position, FMOD_TIMEUNIT_MS);
break;
}
}
}
system->update();
if (channel)
{
unsigned int ms;
unsigned int lenms;
bool playing;
bool paused;
channel->isPlaying(&playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = sound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
}
Sleep(20);
} while (key != 27);
printf("\n");
EnterCriticalSection(&decodecrit);
{
/*
Remove the sound - wait! it might be still in use!
Instead of releasing the decode sound first we could release it last, but this protection is here to make the issue obvious.
*/
result = decodesound->release();
ERRCHECK(result);
decodesound = 0; /* This will make the read callback fail from now on. */
}
LeaveCriticalSection(&decodecrit);
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
DeleteCriticalSection(&decodecrit);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *cdsound;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key, numtracks, currenttrack = 0;
unsigned int version;
if (argc < 2)
{
printf("Usage: cdplayer <drivepath>\n");
printf("Example: cdplayer /dev/cdrom\n");
exit(-1);
}
printf("==================================================================\n");
printf("CDPlayer Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("==================================================================\n\n");
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
/*
Bump up the file buffer size a bit from the 16k default for CDDA, because it is a slower medium.
*/
result = system->setStreamBufferSize(64*1024, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
result = system->createStream(argv[1], FMOD_OPENONLY, 0, &cdsound);
ERRCHECK(result);
result = cdsound->getNumSubSounds(&numtracks);
ERRCHECK(result);
result = cdsound->getSubSound(currenttrack, &sound);
ERRCHECK(result);
for (;;)
{
FMOD_TAG tag;
if (cdsound->getTag(0, -1, &tag) != FMOD_OK)
{
break;
}
if (tag.datatype == FMOD_TAGDATATYPE_CDTOC)
{
dump_cddb_query((FMOD_CDTOC *)tag.data);
}
}
printf("\n========================================\n");
printf("Press SPACE to pause\n");
printf(" n to skip to next track\n");
printf(" ESC to exit\n");
printf("========================================\n\n");
/*
Print out length of entire CD. Did you know you can also play 'cdsound' and it will play the whole CD without gaps?
*/
{
unsigned int lenms;
result = cdsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
ERRCHECK(result);
printf("Total CD length %02d:%02d\n\n", lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100);
}
/*
Play a CD track
*/
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Main loop
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
case 'n' :
{
currenttrack++;
if (currenttrack >= numtracks)
{
currenttrack = 0;
}
result = cdsound->getSubSound(currenttrack, &sound);
ERRCHECK(result);
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
break;
}
}
}
system->update();
if (channel)
{
unsigned int ms;
unsigned int lenms;
bool playing;
bool paused;
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = channel->isPlaying(&playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = sound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
printf("Track %d/%d : %02d:%02d:%02d/%02d:%02d:%02d : %s\r", currenttrack + 1, numtracks, ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *cdsound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int currenttrack = 0, numtracks;
unsigned int version;
printf("==================================================================\n");
printf("CDPlayer Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("==================================================================\n\n");
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
/*
Bump up the file buffer size a bit from the 16k default for CDDA, because it is a slower medium.
*/
result = system->setStreamBufferSize(64*1024, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
/*
Try a few drive letters.
*/
result = system->createStream("d:", FMOD_OPENONLY, 0, &cdsound);
if (result != FMOD_OK)
{
result = system->createStream("e:", FMOD_OPENONLY, 0, &cdsound);
if (result != FMOD_OK)
{
result = system->createStream("f:", FMOD_OPENONLY, 0, &cdsound);
ERRCHECK(result);
}
}
result = cdsound->getNumSubSounds((int *)&numtracks);
ERRCHECK(result);
for (;;)
{
FMOD_TAG tag;
if (cdsound->getTag(0, -1, &tag) != FMOD_OK)
{
break;
}
if (tag.datatype == FMOD_TAGDATATYPE_CDTOC)
{
dump_cddb_query((FMOD_CDTOC *)tag.data);
}
}
printf("\n========================================\n");
printf("Press SPACE to pause\n");
printf(" n to skip to next track\n");
printf(" < re-wind 10 seconds\n");
printf(" > fast-forward 10 seconds\n");
printf(" ESC to exit\n");
printf("========================================\n\n");
/*
Print out length of entire CD. Did you know you can also play 'cdsound' and it will play the whole CD without gaps?
*/
{
unsigned int lenms;
result = cdsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
ERRCHECK(result);
printf("Total CD length %02d:%02d\n\n", lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100);
}
/*
Play whole CD
*/
result = system->playSound(FMOD_CHANNEL_FREE, cdsound, false, &channel);
ERRCHECK(result);
/*
Main loop
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
case '<' :
{
unsigned int ms;
channel->getPosition(&ms, FMOD_TIMEUNIT_SENTENCE_MS);
if (ms >= 10000)
{
ms -= 10000;
}
else
{
ms = 0;
}
channel->setPosition(ms, FMOD_TIMEUNIT_SENTENCE_MS);
break;
}
case '>' :
{
unsigned int ms;
channel->getPosition(&ms, FMOD_TIMEUNIT_SENTENCE_MS);
ms += 10000;
channel->setPosition(ms, FMOD_TIMEUNIT_SENTENCE_MS);
break;
}
case 'n' :
{
channel->getPosition(¤ttrack, FMOD_TIMEUNIT_SENTENCE_SUBSOUND);
currenttrack++;
if (currenttrack >= numtracks)
{
currenttrack = 0;
}
channel->setPosition(currenttrack, FMOD_TIMEUNIT_SENTENCE_SUBSOUND);
break;
}
}
}
system->update();
if (channel)
{
unsigned int ms;
unsigned int lenms;
bool playing;
bool paused;
int busy;
result = channel->getPaused(&paused);
ERRCHECK(result);
result = channel->isPlaying(&playing);
ERRCHECK(result);
result = channel->getPosition(&ms, FMOD_TIMEUNIT_SENTENCE_MS);
ERRCHECK(result);
result = cdsound->getLength(&lenms, FMOD_TIMEUNIT_SENTENCE_MS);
ERRCHECK(result);
result = FMOD::File_GetDiskBusy(&busy);
ERRCHECK(result);
printf("Track %d/%d : %02d:%02d:%02d/%02d:%02d:%02d : %s (%s)\r", currenttrack + 1, numtracks, ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped", busy ? "*" : " ");
}
Sleep(50);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = cdsound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main()
{
// ================================================================================================
// Application-independent initialization
// ================================================================================================
FMOD::System *system;
FMOD_RESULT result;
unsigned int version;
int numDrivers;
FMOD_SPEAKERMODE speakerMode;
FMOD_CAPS caps;
char name[256];
// Create FMOD interface object
result = FMOD::System_Create(&system);
FMODErrorCheck(result);
// Check version
result = system->getVersion(&version);
FMODErrorCheck(result);
if (version < FMOD_VERSION)
{
std::cout << "Error! You are using an old version of FMOD " << version << ". This program requires " << FMOD_VERSION << std::endl;
return 0;
}
// Get number of sound cards
result = system->getNumDrivers(&numDrivers);
FMODErrorCheck(result);
// No sound cards (disable sound)
if (numDrivers == 0)
{
result = system->setOutput(FMOD_OUTPUTTYPE_NOSOUND);
FMODErrorCheck(result);
}
// At least one sound card
else
{
// Get the capabilities of the default (0) sound card
result = system->getDriverCaps(0, &caps, 0, &speakerMode);
FMODErrorCheck(result);
// Set the speaker mode to match that in Control Panel
result = system->setSpeakerMode(speakerMode);
FMODErrorCheck(result);
// Increase buffer size if user has Acceleration slider set to off
if (caps & FMOD_CAPS_HARDWARE_EMULATED)
{
result = system->setDSPBufferSize(1024, 10);
FMODErrorCheck(result);
}
// Get name of driver
result = system->getDriverInfo(0, name, 256, 0);
FMODErrorCheck(result);
// SigmaTel sound devices crackle for some reason if the format is PCM 16-bit.
// PCM floating point output seems to solve it.
if (strstr(name, "SigmaTel"))
{
result = system->setSoftwareFormat(48000, FMOD_SOUND_FORMAT_PCMFLOAT, 0, 0, FMOD_DSP_RESAMPLER_LINEAR);
FMODErrorCheck(result);
}
}
// Initialise FMOD
result = system->init(100, FMOD_INIT_NORMAL, 0);
// If the selected speaker mode isn't supported by this sound card, switch it back to stereo
if (result == FMOD_ERR_OUTPUT_CREATEBUFFER)
{
result = system->setSpeakerMode(FMOD_SPEAKERMODE_STEREO);
FMODErrorCheck(result);
result = system->init(100, FMOD_INIT_NORMAL, 0);
}
FMODErrorCheck(result);
// ================================================================================================
// Application-specific code
// ================================================================================================
bool quit = false;
bool fading = false;
int fadeLength = 3000;
int fadeStartTick;
// Open music as a stream
FMOD::Sound *song1, *song2, *effect;
result = system->createStream("Song1.mp3", FMOD_DEFAULT, 0, &song1);
FMODErrorCheck(result);
result = system->createStream("Song2.mp3", FMOD_DEFAULT, 0, &song2);
FMODErrorCheck(result);
// Load sound effects into memory (not streaming)
result = system->createSound("Effect.mp3", FMOD_DEFAULT, 0, &effect);
FMODErrorCheck(result);
// Assign each song to a channel and start them paused
FMOD::Channel *channel1, *channel2;
result = system->playSound(FMOD_CHANNEL_FREE, song1, true, &channel1);
FMODErrorCheck(result);
result = system->playSound(FMOD_CHANNEL_FREE, song2, true, &channel2);
FMODErrorCheck(result);
// Songs should repeat forever
channel1->setLoopCount(-1);
channel2->setLoopCount(-1);
// Print instructions
std::cout <<
"FMOD Simple Demo - (c) Katy Coe 2012 - www.djkaty.com" << std::endl <<
"=====================================================" << std::endl << std::endl <<
"Press:" << std::endl << std::endl <<
" 1 - Toggle song 1 pause on/off" << std::endl <<
" 2 - Toggle song 2 pause on/off" << std::endl <<
" F - Fade from song 1 to song 2" << std::endl <<
" S - Play one-shot sound effect" << std::endl <<
" Q - Quit" << std::endl;
while (!quit)
{
// Per-frame FMOD update
FMODErrorCheck(system->update());
// Q - Quit
if (GetAsyncKeyState('Q'))
quit = true;
// 1 - Toggle song 1 pause state
if (GetAsyncKeyState('1'))
{
bool isPaused;
channel1->getPaused(&isPaused);
channel1->setPaused(!isPaused);
while (GetAsyncKeyState('1'));
}
// 2 - Toggle song 2 pause state
if (GetAsyncKeyState('2'))
{
bool isPaused;
channel2->getPaused(&isPaused);
channel2->setPaused(!isPaused);
while (GetAsyncKeyState('2'));
}
// F - Begin fade from song 1 to song 2
if (GetAsyncKeyState('F'))
{
channel1->setVolume(1.0f);
channel2->setVolume(0.0f);
channel1->setPaused(false);
channel2->setPaused(false);
fading = true;
fadeStartTick = GetTickCount();
while (GetAsyncKeyState('F'));
}
// Play one-shot sound effect (without storing channel handle)
if (GetAsyncKeyState('S'))
{
system->playSound(FMOD_CHANNEL_FREE, effect, false, 0);
while (GetAsyncKeyState('S'));
}
// Fade function if fade is in progress
if (fading)
{
// Get volume from 0.0f - 1.0f depending on number of milliseconds elapsed since fade started
float volume = min(static_cast<float>(GetTickCount() - fadeStartTick) / fadeLength, 1.0f);
// Fade is over if song 2 has reached full volume
if (volume == 1.0f)
{
fading = false;
channel1->setPaused(true);
channel1->setVolume(1.0f);
}
// Translate linear volume into a smooth sine-squared fade effect
volume = static_cast<float>(sin(volume * M_PI / 2));
volume *= volume;
// Fade song 1 out and song 2 in
channel1->setVolume(1.0f - volume);
channel2->setVolume(volume);
}
}
// Free resources
FMODErrorCheck(song1->release());
FMODErrorCheck(song2->release());
FMODErrorCheck(effect->release());
FMODErrorCheck(system->release());
}
int FMOD_Main()
{
FMOD::System *system;
FMOD::Sound *sound, *sound_to_play;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
unsigned int version;
void *extradriverdata = 0;
int numsubsounds;
Common_Init(&extradriverdata);
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
Common_Fatal("FMOD lib version %08x doesn't match header version %08x", version, FMOD_VERSION);
}
result = system->init(32, FMOD_INIT_NORMAL, extradriverdata);
ERRCHECK(result);
/*
This example uses an FSB file, which is a preferred pack format for fmod containing multiple sounds.
This could just as easily be exchanged with a wav/mp3/ogg file for example, but in this case you wouldnt need to call getSubSound.
Because getNumSubSounds is called here the example would work with both types of sound file (packed vs single).
*/
result = system->createStream(Common_MediaPath("wave_vorbis.fsb"), FMOD_LOOP_NORMAL | FMOD_2D, 0, &sound);
ERRCHECK(result);
result = sound->getNumSubSounds(&numsubsounds);
ERRCHECK(result);
if (numsubsounds)
{
sound->getSubSound(0, &sound_to_play);
ERRCHECK(result);
}
else
{
sound_to_play = sound;
}
/*
Play the sound.
*/
result = system->playSound(sound_to_play, 0, false, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
Common_Update();
if (Common_BtnPress(BTN_ACTION1))
{
bool paused;
result = channel->getPaused(&paused);
ERRCHECK(result);
result = channel->setPaused(!paused);
ERRCHECK(result);
}
result = system->update();
ERRCHECK(result);
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = false;
bool paused = false;
if (channel)
{
result = channel->isPlaying(&playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
result = sound_to_play->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE))
{
ERRCHECK(result);
}
}
Common_Draw("==================================================");
Common_Draw("Play Stream Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2017.");
Common_Draw("==================================================");
Common_Draw("");
Common_Draw("Press %s to toggle pause", Common_BtnStr(BTN_ACTION1));
Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
Common_Draw("");
Common_Draw("Time %02d:%02d:%02d/%02d:%02d:%02d : %s", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped");
}
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Shut down
*/
result = sound->release(); /* Release the parent, not the sound that was retrieved with getSubSound. */
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
Common_Close();
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Sound *subsound[2];
FMOD_CREATESOUNDEXINFO exinfo;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int subsoundid, sentenceid;
unsigned int version;
const char *soundname[NUMSOUNDS] =
{
"../media/e.ogg", /* Ma- */
"../media/d.ogg", /* ry */
"../media/c.ogg", /* had */
"../media/d.ogg", /* a */
"../media/e.ogg", /* lit- */
"../media/e.ogg", /* tle */
"../media/e.ogg", /* lamb, */
"../media/e.ogg", /* ..... */
"../media/d.ogg", /* lit- */
"../media/d.ogg", /* tle */
"../media/d.ogg", /* lamb, */
"../media/d.ogg", /* ..... */
"../media/e.ogg", /* lit- */
"../media/e.ogg", /* tle */
"../media/e.ogg", /* lamb, */
"../media/e.ogg", /* ..... */
"../media/e.ogg", /* Ma- */
"../media/d.ogg", /* ry */
"../media/c.ogg", /* had */
"../media/d.ogg", /* a */
"../media/e.ogg", /* lit- */
"../media/e.ogg", /* tle */
"../media/e.ogg", /* lamb, */
"../media/e.ogg", /* its */
"../media/d.ogg", /* fleece */
"../media/d.ogg", /* was */
"../media/e.ogg", /* white */
"../media/d.ogg", /* as */
"../media/c.ogg", /* snow. */
"../media/c.ogg", /* ..... */
"../media/c.ogg", /* ..... */
"../media/c.ogg", /* ..... */
};
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
ERRCHECK(result);
result = system->getVersion(&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);
return 0;
}
result = system->init(1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
/*
Set up the FMOD_CREATESOUNDEXINFO structure for the user stream with room for 2 subsounds. (our subsound double buffer)
*/
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.defaultfrequency = 44100;
exinfo.numsubsounds = 2;
exinfo.numchannels = 1;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
/*
Create the 'parent' stream that contains the substreams. Set it to loop so that it loops between subsound 0 and 1.
*/
result = system->createStream(0, FMOD_LOOP_NORMAL | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
/*
Add 2 of our streams as children of the parent. They should be the same format (ie mono/stereo and bitdepth) as the parent sound.
When subsound 0 has finished and it is playing subsound 1, we will swap subsound 0 with a new sound, and the same for when subsound 1 has finished,
causing a continual double buffered flip, which means continuous sound.
*/
result = system->createStream(soundname[0], FMOD_DEFAULT, 0, &subsound[0]);
ERRCHECK(result);
result = system->createStream(soundname[1], FMOD_DEFAULT, 0, &subsound[1]);
ERRCHECK(result);
result = sound->setSubSound(0, subsound[0]);
ERRCHECK(result);
result = sound->setSubSound(1, subsound[1]);
ERRCHECK(result);
/*
Set up the gapless sentence to contain these first 2 streams.
*/
{
int soundlist[2] = { 0, 1 };
result = sound->setSubSoundSentence(soundlist, 2);
ERRCHECK(result);
}
subsoundid = 0;
sentenceid = 2; /* The next sound to be appeneded to the stream. */
printf("=============================================================================\n");
printf("Real-time stitching example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("=============================================================================\n");
printf("\n");
printf("Press space to pause, Esc to quit\n");
printf("\n");
printf("Inserted subsound %d / 2 with sound %d / %d\n", 0, 0, NUMSOUNDS);
printf("Inserted subsound %d / 2 with sound %d / %d\n", 1, 1, NUMSOUNDS);
/*
Play the sound.
*/
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
unsigned int currentsubsoundid;
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
}
}
system->update();
/*
Replace the subsound that just finished with a new subsound, to create endless seamless stitching!
Note that this polls the currently playing subsound using the FMOD_TIMEUNIT_BUFFERED flag.
Remember streams are decoded / buffered ahead in advance!
Don't use the 'audible time' which is FMOD_TIMEUNIT_SENTENCE_SUBSOUND by itself. When streaming, sound is
processed ahead of time, and things like stream buffer / sentence manipulation (as done below) is required
to be in 'buffered time', or else there will be synchronization problems and you might end up releasing a
sub-sound that is still playing!
*/
result = channel->getPosition(¤tsubsoundid, (FMOD_TIMEUNIT)(FMOD_TIMEUNIT_SENTENCE_SUBSOUND | FMOD_TIMEUNIT_BUFFERED));
ERRCHECK(result);
if (currentsubsoundid != subsoundid)
{
/*
Release the sound that isn't playing any more.
*/
result = subsound[subsoundid]->release();
ERRCHECK(result);
/*
Replace it with a new sound in our list.
*/
result = system->createStream(soundname[sentenceid], FMOD_DEFAULT, 0, &subsound[subsoundid]);
ERRCHECK(result);
result = sound->setSubSound(subsoundid, subsound[subsoundid]);
ERRCHECK(result);
printf("Replacing subsound %d / 2 with sound %d / %d\n", subsoundid, sentenceid, NUMSOUNDS);
sentenceid++;
if (sentenceid >= NUMSOUNDS)
{
sentenceid = 0;
}
subsoundid = currentsubsoundid;
}
Sleep(50);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release(); /* Freeing a parent subsound also frees its children. */
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}