int FMOD_Main()
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel;
FMOD::DSP *mydsp;
FMOD::ChannelGroup *mastergroup;
FMOD_RESULT result;
unsigned int version;
void *extradriverdata = 0;
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);
result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_LOOP_NORMAL, 0, &sound);
ERRCHECK(result);
result = system->playSound(sound, 0, false, &channel);
ERRCHECK(result);
/*
Create the DSP effect.
*/
{
FMOD_DSP_DESCRIPTION dspdesc;
memset(&dspdesc, 0, sizeof(dspdesc));
strncpy(dspdesc.name, "My first DSP unit", sizeof(dspdesc.name));
dspdesc.version = 0x00010000;
dspdesc.numinputbuffers = 1;
dspdesc.numoutputbuffers = 1;
dspdesc.read = myDSPCallback;
dspdesc.userdata = (void *)0x12345678;
result = system->createDSP(&dspdesc, &mydsp);
ERRCHECK(result);
}
/*
Attach the DSP, inactive by default.
*/
result = mydsp->setBypass(true);
ERRCHECK(result);
result = system->getMasterChannelGroup(&mastergroup);
ERRCHECK(result);
result = mastergroup->addDSP(0, mydsp);
ERRCHECK(result);
/*
Main loop.
*/
do
{
bool bypass;
Common_Update();
result = mydsp->getBypass(&bypass);
ERRCHECK(result);
if (Common_BtnPress(BTN_ACTION1))
{
bypass = !bypass;
result = mydsp->setBypass(bypass);
ERRCHECK(result);
}
result = system->update();
ERRCHECK(result);
Common_Draw("==================================================");
Common_Draw("Custom DSP Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2015.");
Common_Draw("==================================================");
Common_Draw("");
Common_Draw("Press %s to toggle filter bypass", Common_BtnStr(BTN_ACTION1));
Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
Common_Draw("");
Common_Draw("Filter is %s", bypass ? "inactive" : "active");
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = mastergroup->removeDSP(mydsp);
ERRCHECK(result);
result = mydsp->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
Common_Close();
return 0;
}
int FMOD_Main()
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
unsigned int version;
void *extradriverdata = 0;
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);
result = system->createSound(Common_MediaPath("wave.mp3"), FMOD_HARDWARE | FMOD_LOOP_NORMAL | FMOD_2D, 0, &sound);
ERRCHECK(result);
/*
Play the sound.
*/
result = system->playSound(sound, 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->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-2013.");
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();
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::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");
}
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 = 0;
FMOD::Sound *sound = 0;
FMOD_RESULT result;
FMOD_CREATESOUNDEXINFO exinfo;
int key, recorddriver, numdrivers, count;
unsigned int version;
FILE *fp;
unsigned int datalength = 0, soundlength;
bool iscoreaudio = false;
/*
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->setOutput(FMOD_OUTPUTTYPE_COREAUDIO);
ERRCHECK(result);
/*
Enumerate record devices
*/
result = system->getRecordNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getRecordDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
recorddriver = 0;
do
{
key = getch();
if (key == 27)
{
return 0;
}
recorddriver = key - '1';
} while (recorddriver < 0 || recorddriver >= numdrivers);
printf("\n");
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 2;
exinfo.defaultfrequency = 44100;
if (iscoreaudio)
{
exinfo.format = FMOD_SOUND_FORMAT_PCMFLOAT;
exinfo.length = exinfo.defaultfrequency * sizeof(float) * exinfo.numchannels * 2;
}
else
{
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 2;
}
result = system->createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
printf("========================================================================\n");
printf("Record to disk example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("========================================================================\n");
printf("\n");
printf("Press a key to start recording to record.wav\n");
printf("\n");
getch();
result = system->recordStart(recorddriver, sound, true);
ERRCHECK(result);
printf("Press 'Esc' to quit\n");
printf("\n");
fp = fopen("record.wav", "wb");
if (!fp)
{
printf("ERROR : could not open record.wav for writing.\n");
return 1;
}
/*
Write out the wav header. As we don't know the length yet it will be 0.
*/
WriteWavHeader(fp, sound, datalength);
result = sound->getLength(&soundlength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
/*
Main loop.
*/
do
{
static unsigned int lastrecordpos = 0;
unsigned int recordpos = 0;
if (kbhit())
{
key = getch();
}
system->getRecordPosition(recorddriver, &recordpos);
ERRCHECK(result);
if (recordpos != lastrecordpos)
{
void *ptr1, *ptr2;
int blocklength;
unsigned int len1, len2;
blocklength = (int)recordpos - (int)lastrecordpos;
if (blocklength < 0)
{
blocklength += soundlength;
}
/*
Lock the sound to get access to the raw data.
*/
if(iscoreaudio)
{
sound->lock(lastrecordpos * 8, blocklength * 8, &ptr1, &ptr2, &len1, &len2); /* *8 = stereo 32bit. 1 sample = 8 bytes. */
}
else
{
sound->lock(lastrecordpos * 4, blocklength * 4, &ptr1, &ptr2, &len1, &len2); /* *4 = stereo 16bit. 1 sample = 4 bytes. */
}
/*
Write it to disk.
*/
if (ptr1 && len1)
{
#ifdef __BIG_ENDIAN__
if (exinfo.format == FMOD_SOUND_FORMAT_PCM16)
{
signed short *wptr = (signed short *)ptr1;
for (int count = 0; count < len1 >> 1; count++)
{
wptr[count] = SWAPENDIAN_WORD(wptr[count]);
}
}
else if (exinfo.format == FMOD_SOUND_FORMAT_PCMFLOAT)
{
float *fptr = (float *)ptr1;
for (int count = 0; count < len1 >> 2; count++)
{
SWAPENDIAN_FLOAT(fptr[count]);
}
}
#endif
datalength += fwrite(ptr1, 1, len1, fp);
}
if (ptr2 && len2)
{
#ifdef __BIG_ENDIAN__
if (exinfo.format == FMOD_SOUND_FORMAT_PCM16)
{
signed short *wptr = (signed short *)ptr2;
for (int count = 0; count < len2 >> 1; count++)
{
wptr[count] = SWAPENDIAN_WORD(wptr[count]);
}
}
else if (exinfo.format == FMOD_SOUND_FORMAT_PCMFLOAT)
{
float *fptr = (float *)ptr2;
for (int count = 0; count < len2 >> 2; count++)
{
SWAPENDIAN_FLOAT(fptr[count]);
}
}
#endif
datalength += fwrite(ptr2, 1, len2, fp);
}
/*
Unlock the sound to allow FMOD to use it again.
*/
sound->unlock(ptr1, ptr2, len1, len2);
}
lastrecordpos = recordpos;
printf("\rRecord buffer pos = %6d : Record time = %02d:%02d", recordpos, datalength / exinfo.defaultfrequency / 4 / 60, (datalength / exinfo.defaultfrequency / 4) % 60);
fflush(stdout);
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Write back the wav header now that we know its length.
*/
WriteWavHeader(fp, sound, datalength);
fclose(fp);
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int FMOD_Main()
{
FMOD::System *system;
FMOD::Sound *sound1, *sound2;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
unsigned int version;
int selection = 0;
void *extradriverdata = 0;
FMOD_SPEAKERMODE speakermode = FMOD_SPEAKERMODE_STEREO;
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);
result = system->getSoftwareFormat(0, &speakermode, 0);
ERRCHECK(result);
result = system->createSound(Common_MediaPath("drumloop.wav"), FMOD_2D | FMOD_LOOP_OFF, 0, &sound1);
ERRCHECK(result);
result = system->createSound(Common_MediaPath("stereo.ogg"), FMOD_2D | FMOD_LOOP_OFF, 0, &sound2);
ERRCHECK(result);
/*
Main loop.
*/
do
{
Common_Update();
if (Common_BtnPress(BTN_UP) && (selection != 0))
{
selection--;
}
if (Common_BtnPress(BTN_DOWN) && (selection != (SELECTION_COUNT - 1)))
{
selection++;
}
if (Common_BtnPress(BTN_ACTION1) && isSelectionAvailable(speakermode, selection))
{
if (selection == 0) /* Mono front left */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(1.0f, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 1) /* Mono front right */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 1.0f, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 2) /* Mono center */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 0, 1.0f, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 3) /* Mono surround left */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 0, 0, 0, 1.0f, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 4) /* Mono surround right */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 1.0f, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 5) /* Mono rear left */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 0, 1.0f, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 6) /* Mono rear right */
{
result = system->playSound(sound1, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixLevelsOutput(0, 0, 0, 0, 0, 0, 0, 1.0f);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 7) /* Stereo front */
{
result = system->playSound(sound2, 0, false, &channel);
ERRCHECK(result);
}
else if (selection == 8) /* Stereo front channel swapped */
{
float matrix[] = { 0.0f, 1.0f,
1.0f, 0.0f };
result = system->playSound(sound2, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixMatrix(matrix, 2, 2);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
else if (selection == 9) /* Stereo (right only) center */
{
float matrix[] = { 0.0f, 0.0f,
0.0f, 0.0f,
0.0f, 1.0f };
result = system->playSound(sound2, 0, true, &channel);
ERRCHECK(result);
result = channel->setMixMatrix(matrix, 3, 2);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
}
result = system->update();
ERRCHECK(result);
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = false;
bool paused = false;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
result = system->getChannelsPlaying(&channelsplaying);
ERRCHECK(result);
Common_Draw("==================================================");
Common_Draw("Multiple Speaker Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2015.");
Common_Draw("==================================================");
Common_Draw("");
Common_Draw("Speaker mode is set to %s%s", SPEAKERMODE_STRING[speakermode], speakermode < FMOD_SPEAKERMODE_7POINT1 ? " causing some speaker options to be unavailable" : "");
Common_Draw("");
Common_Draw("Press %s or %s to select mode", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
Common_Draw("Press %s to play the sound", Common_BtnStr(BTN_ACTION1));
for (int i = 0; i < SELECTION_COUNT; i++)
{
bool disabled = !isSelectionAvailable(speakermode, i);
Common_Draw("[%c] %s%s", (selection == i) ? (disabled ? '-' : 'X') : ' ', disabled ? "[N/A] " : "", SELECTION_STRING[i]);
}
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_Draw("Channels playing: %d", channelsplaying);
}
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Shut down
*/
result = sound1->release();
ERRCHECK(result);
result = sound2->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
Common_Close();
return 0;
}
int FMOD_Main()
{
FMOD::System *system;
FMOD::Sound *sound1, *sound2, *sound3;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
unsigned int version;
void *extradriverdata = 0;
void *buff = 0;
int length = 0;
FMOD_CREATESOUNDEXINFO exinfo;
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);
Common_LoadFileMemory(Common_MediaPath("drumloop.wav"), &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_HARDWARE | FMOD_OPENMEMORY | FMOD_LOOP_OFF, &exinfo, &sound1);
ERRCHECK(result);
Common_UnloadFileMemory(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
Common_LoadFileMemory(Common_MediaPath("jaguar.wav"), &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_SOFTWARE | FMOD_OPENMEMORY, &exinfo, &sound2);
ERRCHECK(result);
Common_UnloadFileMemory(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
Common_LoadFileMemory(Common_MediaPath("swish.wav"), &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_HARDWARE | FMOD_OPENMEMORY, &exinfo, &sound3);
ERRCHECK(result);
Common_UnloadFileMemory(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
/*
Main loop
*/
do
{
Common_Update();
if (Common_BtnPress(BTN_ACTION1))
{
result = system->playSound(sound1, 0, false, &channel);
ERRCHECK(result);
}
if (Common_BtnPress(BTN_ACTION2))
{
result = system->playSound(sound2, 0, false, &channel);
ERRCHECK(result);
}
if (Common_BtnPress(BTN_ACTION3))
{
result = system->playSound(sound3, 0, false, &channel);
ERRCHECK(result);
}
result = system->update();
ERRCHECK(result);
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = 0;
bool paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
system->getChannelsPlaying(&channelsplaying);
Common_Draw("==================================================");
Common_Draw("Load From Memory Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2014.");
Common_Draw("==================================================");
Common_Draw("");
Common_Draw("Press %s to play a mono sound (drumloop)", Common_BtnStr(BTN_ACTION1));
Common_Draw("Press %s to play a mono sound (jaguar)", Common_BtnStr(BTN_ACTION2));
Common_Draw("Press %s to play a stereo sound (swish)", Common_BtnStr(BTN_ACTION3));
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_Draw("Channels Playing %2d", channelsplaying);
}
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Shut down
*/
result = sound1->release();
ERRCHECK(result);
result = sound2->release();
ERRCHECK(result);
result = sound3->release();
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::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int version;
memset(gCurrentTrackArtist, 0, 256);
memset(gCurrentTrackTitle, 0, 256);
strcpy(gOutputFileName, "output.mp3"); /* Start off like this then rename if a title tag comes along */
printf("======================================================================\n");
printf("RipNetStream Example. Copyright (c) Firelight Technologies 2004-2015.\n");
printf("======================================================================\n\n");
if (argc < 2)
{
printf("Usage: ripnetstream <url>\n");
return -1;
}
/*
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(100, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->setStreamBufferSize(gFileBufferSize, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
result = system->attachFileSystem(myopen, myclose, myread, 0);
ERRCHECK(result);
printf("Buffering...\n\n");
result = system->createSound(argv[1], FMOD_HARDWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_NONBLOCKING, 0, &sound);
ERRCHECK(result);
/*
Main loop
*/
do
{
static bool mute = false;
if (sound && !channel)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
}
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
if (channel)
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
}
break;
}
case 'm' :
case 'M' :
{
if (channel)
{
channel->getMute(&mute);
channel->setMute(!mute);
}
break;
}
}
}
system->update();
if (channel)
{
bool playing = false;
int tagsupdated = 0;
sound->getNumTags(0, &tagsupdated);
if (tagsupdated)
{
printf("\n");
printf("\n");
for (;;)
{
FMOD_TAG tag;
if (sound->getTag(0, -1, &tag) != FMOD_OK)
{
break;
}
if (tag.datatype == FMOD_TAGDATATYPE_STRING)
{
printf("[%-11s] %s (%d bytes)\n", tag.name, tag.data, tag.datalen);
sound->getFormat(&gSoundType, 0, 0, 0);
if (!strcmp(tag.name, "ARTIST"))
{
if (strncmp(gCurrentTrackArtist, (const char *)tag.data, 256))
{
strncpy(gCurrentTrackArtist, (const char *)tag.data, 256);
gUpdateFileName = true;
}
}
if (!strcmp(tag.name, "TITLE"))
{
if (strncmp(gCurrentTrackTitle, (const char *)tag.data, 256))
{
strncpy(gCurrentTrackTitle, (const char *)tag.data, 256);
gUpdateFileName = true;
}
}
}
}
printf("\n");
}
result = channel->isPlaying(&playing);
if (result != FMOD_OK || !playing)
{
sound->release();
sound = 0;
channel = 0;
}
else
{
unsigned int ms = 0, percent = 0;
bool paused = false;
bool starving = false;
FMOD_OPENSTATE openstate;
result = sound->getOpenState(&openstate, &percent, &starving, 0);
ERRCHECK(result);
channel->setVolume(starving ? 0.0f : 1.0f); /* Don't use mute because the user is setting that. */
ERRCHECK(result);
result = channel->getPaused(&paused);
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
printf("Time %02d:%02d:%02d : (%3d%%%) %s SPACE = pause. 'm' = mute. ESC = quit.\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, percent, (openstate == FMOD_OPENSTATE_BUFFERING || starving) ? "Buffering..." : openstate == FMOD_OPENSTATE_CONNECTING ? "Connecting..." : paused ? "Paused " : playing ? "Playing " : "Stopped ", percent, starving ? "STARVING" : " ");
}
}
if (sound)
{
FMOD_OPENSTATE openstate = FMOD_OPENSTATE_READY;
sound->getOpenState(&openstate, 0, 0, 0);
if (openstate == FMOD_OPENSTATE_ERROR)
{
sound->release();
sound = 0;
channel = 0;
}
}
if (!sound)
{
printf("\n");
printf("Error occurred or stream ended. Restarting stream..\n");
result = system->createSound(argv[1], FMOD_HARDWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_NONBLOCKING, 0, &sound);
ERRCHECK(result);
Sleep(1000);
}
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;
FMOD::DSP *dsplowpass, *dspchorus, *dsphead, *dspchannelmixer;
FMOD::DSPConnection *dsplowpassconnection, *dspchorusconnection;
FMOD_RESULT result;
int key;
unsigned int version;
float pan = 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(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createSound("../media/drumloop.wav", FMOD_SOFTWARE | FMOD_LOOP_NORMAL, 0, &sound);
ERRCHECK(result);
printf("===============================================================================\n");
printf("DSP effect per speaker example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("===============================================================================\n");
printf("Press 'L' to toggle lowpass on/off on left speaker only\n");
printf("Press 'R' to toggle chorus on/off on right speaker only\n");
printf("Press '[' to pan sound left\n");
printf("Press ']' to pan sound right\n");
printf("Press 'Esc' to quit\n");
printf("\n");
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Create the DSP effects.
*/
result = system->createDSPByType(FMOD_DSP_TYPE_LOWPASS, &dsplowpass);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_CHORUS, &dspchorus);
ERRCHECK(result);
/*
Connect up the DSP network
*/
/*
When a sound is played, a subnetwork is set up in the DSP network which looks like this.
Wavetable is the drumloop sound, and it feeds its data from right to left.
[DSPHEAD]<------------[DSPCHANNELMIXER]
*/
result = system->getDSPHead(&dsphead);
ERRCHECK(result);
result = dsphead->getInput(0, &dspchannelmixer, 0);
ERRCHECK(result);
/*
Now disconnect channeldsp head from wavetable to look like this.
[DSPHEAD] [DSPCHANNELMIXER]
*/
result = dsphead->disconnectFrom(dspchannelmixer);
ERRCHECK(result);
/*
Now connect the 2 effects to channeldsp head.
Store the 2 connections this makes so we can set their speakerlevels later.
[DSPLOWPASS]
/x
[DSPHEAD] [DSPCHANNELMIXER]
\y
[DSPCHORUS]
*/
result = dsphead->addInput(dsplowpass, &dsplowpassconnection); /* x = dsplowpassconnection */
ERRCHECK(result);
result = dsphead->addInput(dspchorus, &dspchorusconnection); /* y = dspchorusconnection */
ERRCHECK(result);
/*
Now connect the wavetable to the 2 effects
[DSPLOWPASS]
/x \
[DSPHEAD] [DSPCHANNELMIXER]
\y /
[DSPCHORUS]
*/
result = dsplowpass->addInput(dspchannelmixer, 0); /* Null for connection - we dont care about it. */
ERRCHECK(result);
result = dspchorus->addInput(dspchannelmixer, 0); /* Null for connection - we dont care about it. */
ERRCHECK(result);
/*
Now the drumloop will be twice as loud, because it is being split into 2, then recombined at the end.
What we really want is to only feed the dspchannelmixer->dsplowpass through the left speaker, and
dspchannelmixer->dspchorus to the right speaker.
We can do that simply by setting the pan, or speaker levels of the connections.
[DSPLOWPASS]
/x=1,0 \
[DSPHEAD] [DSPCHANNELMIXER]
\y=0,1 /
[DSPCHORUS]
*/
{
float leftinputon[2] = { 1.0f, 0.0f };
float rightinputon[2] = { 0.0f, 1.0f };
float inputsoff[2] = { 0.0f, 0.0f };
result = dsplowpassconnection->setLevels(FMOD_SPEAKER_FRONT_LEFT, leftinputon, 2);
ERRCHECK(result);
result = dsplowpassconnection->setLevels(FMOD_SPEAKER_FRONT_RIGHT, inputsoff, 2);
ERRCHECK(result);
result = dspchorusconnection->setLevels(FMOD_SPEAKER_FRONT_LEFT, inputsoff, 2);
ERRCHECK(result);
result = dspchorusconnection->setLevels(FMOD_SPEAKER_FRONT_RIGHT, rightinputon, 2);
ERRCHECK(result);
}
result = dsplowpass->setBypass(true);
result = dspchorus->setBypass(true);
result = dsplowpass->setActive(true);
result = dspchorus->setActive(true);
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case 'l' :
case 'L' :
{
static bool lowpass = false;
dsplowpass->setBypass(lowpass);
lowpass = !lowpass;
break;
}
case 'r' :
case 'R' :
{
static bool chorus = false;
dspchorus->setBypass(chorus);
chorus = !chorus;
break;
}
case '[' :
{
channel->getPan(&pan);
pan -= 0.1f;
if (pan < -1)
{
pan = -1;
}
channel->setPan(pan);
break;
}
case ']' :
{
channel->getPan(&pan);
pan += 0.1f;
if (pan > 1)
{
pan = 1;
}
channel->setPan(pan);
break;
}
}
}
system->update();
{
int channelsplaying = 0;
system->getChannelsPlaying(&channelsplaying);
printf("Channels Playing %2d : Pan = %.02f\r", channelsplaying, pan);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = dsplowpass->release();
ERRCHECK(result);
result = dspchorus->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 *sound1, *sound2, *sound3;
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);
getch();
return 0;
}
result = system->setOutput(FMOD_OUTPUTTYPE_ALSA);
ERRCHECK(result);
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createSound("../media/drumloop.wav", FMOD_SOFTWARE, 0, &sound1);
ERRCHECK(result);
result = sound1->setMode(FMOD_LOOP_OFF);
ERRCHECK(result);
result = system->createSound("../media/jaguar.wav", FMOD_SOFTWARE, 0, &sound2);
ERRCHECK(result);
result = system->createSound("../media/swish.wav", FMOD_SOFTWARE, 0, &sound3);
ERRCHECK(result);
printf("===================================================================\n");
printf("PlaySound Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("===================================================================\n");
printf("\n");
printf("Press '1' to Play a mono sound using software mixing\n");
printf("Press '2' to Play a mono sound using software mixing\n");
printf("Press '3' to Play a stereo sound using software mixing\n");
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop.
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case '1' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, 0, &channel);
ERRCHECK(result);
break;
}
case '2' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound2, 0, &channel);
ERRCHECK(result);
break;
}
case '3' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound3, 0, &channel);
ERRCHECK(result);
break;
}
}
}
system->update();
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = 0;
bool paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
system->getChannelsPlaying(&channelsplaying);
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped", channelsplaying);
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound1->release();
ERRCHECK(result);
result = sound2->release();
ERRCHECK(result);
result = sound3->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system = 0;
FMOD::Sound *sound = 0;
FMOD_RESULT result;
FMOD_CREATESOUNDEXINFO exinfo;
int key, recorddriver, numdrivers, count;
unsigned int version;
FILE *fp;
unsigned int datalength = 0, soundlength;
/*
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;
}
/*
System initialization
*/
printf("---------------------------------------------------------\n");
printf("Select OUTPUT type\n");
printf("---------------------------------------------------------\n");
printf("1 : DirectSound\n");
printf("2 : Windows Multimedia WaveOut\n");
printf("3 : ASIO\n");
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
key = _getch();
} while (key != 27 && key < '1' && key > '5');
switch (key)
{
case '1' : result = system->setOutput(FMOD_OUTPUTTYPE_DSOUND);
break;
case '2' : result = system->setOutput(FMOD_OUTPUTTYPE_WINMM);
break;
case '3' : result = system->setOutput(FMOD_OUTPUTTYPE_ASIO);
break;
default : return 1;
}
ERRCHECK(result);
/*
Enumerate record devices
*/
result = system->getRecordNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getRecordDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
recorddriver = 0;
do
{
key = _getch();
if (key == 27)
{
return 0;
}
recorddriver = key - '1';
} while (recorddriver < 0 || recorddriver >= numdrivers);
printf("\n");
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 1;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.defaultfrequency = 44100;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 2;
result = system->createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
printf("========================================================================\n");
printf("Record to disk example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("========================================================================\n");
printf("\n");
printf("Press a key to start recording to record.wav\n");
printf("\n");
_getch();
result = system->recordStart(recorddriver, sound, true);
ERRCHECK(result);
printf("Press 'Esc' to quit\n");
printf("\n");
fp = fopen("record.wav", "wb");
if (!fp)
{
printf("ERROR : could not open record.wav for writing.\n");
return 1;
}
/*
Write out the wav header. As we don't know the length yet it will be 0.
*/
WriteWavHeader(fp, sound, datalength);
result = sound->getLength(&soundlength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
/*
Main loop.
*/
do
{
static unsigned int lastrecordpos = 0;
unsigned int recordpos = 0;
if (_kbhit())
{
key = _getch();
}
system->getRecordPosition(recorddriver, &recordpos);
ERRCHECK(result);
if (recordpos != lastrecordpos)
{
void *ptr1, *ptr2;
int blocklength;
unsigned int len1, len2;
blocklength = (int)recordpos - (int)lastrecordpos;
if (blocklength < 0)
{
blocklength += soundlength;
}
/*
Lock the sound to get access to the raw data.
*/
sound->lock(lastrecordpos * exinfo.numchannels * 2, blocklength * exinfo.numchannels * 2, &ptr1, &ptr2, &len1, &len2); /* * exinfo.numchannels * 2 = stereo 16bit. 1 sample = 4 bytes. */
/*
Write it to disk.
*/
if (ptr1 && len1)
{
datalength += fwrite(ptr1, 1, len1, fp);
}
if (ptr2 && len2)
{
datalength += fwrite(ptr2, 1, len2, fp);
}
/*
Unlock the sound to allow FMOD to use it again.
*/
sound->unlock(ptr1, ptr2, len1, len2);
}
lastrecordpos = recordpos;
printf("%-23s. Record buffer pos = %6d : Record time = %02d:%02d\r", (timeGetTime() / 500) & 1 ? "Recording to record.wav" : "", recordpos, datalength / exinfo.defaultfrequency / exinfo.numchannels / 2 / 60, (datalength / exinfo.defaultfrequency / exinfo.numchannels / 2) % 60);
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Write back the wav header now that we know its length.
*/
WriteWavHeader(fp, sound, datalength);
fclose(fp);
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system = 0;
FMOD::Sound *sound = 0;
FMOD::Channel *channel = 0;
FMOD::DSP *dsp = 0;
FMOD_RESULT result;
FMOD_CREATESOUNDEXINFO exinfo;
FMOD_SPEAKERMODE speakermode;
FMOD_CAPS caps;
int key, numdrivers;
unsigned int version;
unsigned int datalength = 0, soundlength;
char name[256];
unsigned int adjustedlatency;
/*
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;
}
/*
System initialization (recommended startup sequence)
*/
result = system->getNumDrivers(&numdrivers);
ERRCHECK(result);
if (numdrivers == 0)
{
result = system->setOutput(FMOD_OUTPUTTYPE_NOSOUND);
ERRCHECK(result);
}
else
{
result = system->getDriverCaps(0, &caps, 0, &speakermode);
ERRCHECK(result);
result = system->setSpeakerMode(speakermode); /* Set the user selected speaker mode. */
ERRCHECK(result);
if (caps & FMOD_CAPS_HARDWARE_EMULATED) /* The user has the 'Acceleration' slider set to off! This is really bad for latency!. */
{ /* You might want to warn the user about this. */
result = system->setDSPBufferSize(1024, 10);
ERRCHECK(result);
}
#ifdef LOWLATENCY
else
{
result = system->setDSPBufferSize(256, 4);
}
#endif
result = system->getDriverInfo(0, name, 256, 0);
ERRCHECK(result);
if (strstr(name, "SigmaTel")) /* Sigmatel sound devices crackle for some reason if the format is PCM 16bit. PCM floating point output seems to solve it. */
{
result = system->setSoftwareFormat(48000, FMOD_SOUND_FORMAT_PCMFLOAT, 0,0, FMOD_DSP_RESAMPLER_LINEAR);
ERRCHECK(result);
}
}
result = system->init(100, FMOD_INIT_NORMAL, 0);
if (result == FMOD_ERR_OUTPUT_CREATEBUFFER) /* Ok, the speaker mode selected isn't supported by this soundcard. Switch it back to stereo... */
{
result = system->setSpeakerMode(FMOD_SPEAKERMODE_STEREO);
ERRCHECK(result);
result = system->init(100, FMOD_INIT_NORMAL, 0);/* ... and re-init. */
ERRCHECK(result);
}
/*
System initialization complete (recommended startup sequence)
*/
/*
Create user sound to record into. Set it to loop for playback.
*/
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 1;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.defaultfrequency = RECORDRATE;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 5; /* 5 second buffer, doesnt really matter how big this is, but not too small of course. */
result = system->createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_LOOP_NORMAL | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
printf("========================================================================\n");
printf("Record with realtime playback example.\n");
printf("Copyright (c) Firelight Technologies 2004-2014.\n");
printf("\n");
printf("Try #define LOWLATENCY to reduce latency for more modern machines!\n");
printf("========================================================================\n");
printf("\n");
printf("Press a key to start recording. Playback will start %d samples (%d ms) later.\n", LATENCY, LATENCY * 1000 / RECORDRATE);
printf("\n");
_getch();
printf("Press 'E' to toggle an effect on/off.\n");
printf("Press 'Esc' to quit\n");
printf("\n");
result = system->recordStart(0, sound, true);
ERRCHECK(result);
result = sound->getLength(&soundlength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
/*
Create a DSP effect to play with.
*/
result = system->createDSPByType(FMOD_DSP_TYPE_FLANGE, &dsp);
ERRCHECK(result);
result = dsp->setParameter(FMOD_DSP_FLANGE_RATE, 4.0f);
ERRCHECK(result);
result = dsp->setBypass(true);
ERRCHECK(result);
adjustedlatency = LATENCY; /* This might change depending on record block size. */
/*
Main loop.
*/
do
{
static unsigned int lastrecordpos = 0, samplesrecorded = 0;
unsigned int recordpos = 0, recorddelta;
key = 0;
if (_kbhit())
{
key = _getch();
}
if (key == 'e' || key == 'E')
{
bool bypass;
dsp->getBypass(&bypass);
dsp->setBypass(!bypass);
if (bypass)
{
FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_CONCERTHALL;
system->setReverbProperties(&prop);
}
else
{
FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_OFF;
system->setReverbProperties(&prop);
}
printf("\n\n *** TURN DSP EFFECT %s ** \n\n", bypass ? "ON" : "OFF");
}
system->getRecordPosition(0, &recordpos);
ERRCHECK(result);
recorddelta = recordpos >= lastrecordpos ? recordpos - lastrecordpos : recordpos + soundlength - lastrecordpos;
samplesrecorded += recorddelta;
if (samplesrecorded >= adjustedlatency && !channel)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
result = channel->addDSP(dsp, 0);
ERRCHECK(result);
}
if (channel && recorddelta)
{
unsigned int playrecorddelta;
unsigned int playpos = 0;
int adjusting = 0;
float smootheddelta;
float dampratio = 0.97f;
static unsigned int minrecorddelta = (unsigned int)-1;
/*
If the record driver steps the position of the record cursor in larger increments than the user defined latency value, then we should
increase our latency value to match.
*/
if (recorddelta < minrecorddelta)
{
minrecorddelta = recorddelta;
if (adjustedlatency < recorddelta)
{
adjustedlatency = recorddelta;
}
}
channel->getPosition(&playpos, FMOD_TIMEUNIT_PCM);
playrecorddelta = recordpos >= playpos ? recordpos - playpos : recordpos + soundlength - playpos;
/*
Smooth total
*/
{
static float total = 0;
total = total * dampratio;
total += playrecorddelta;
smootheddelta = total * (1.0f - dampratio);
}
if (smootheddelta < adjustedlatency - DRIFTTHRESHOLD || smootheddelta > soundlength / 2) /* if play cursor is catching up to record (or passed it), slow playback down */
{
channel->setFrequency(RECORDRATE - (RECORDRATE / 50)); /* Decrease speed by 2% */
adjusting = 1;
}
else if (smootheddelta > adjustedlatency + DRIFTTHRESHOLD) /* if play cursor is falling too far behind record, speed playback up */
{
channel->setFrequency(RECORDRATE + (RECORDRATE / 50)); /* Increase speed by 2% */
adjusting = 2;
}
else
{
channel->setFrequency(RECORDRATE); /* Otherwise set to normal rate */
adjusting = 0;
}
printf("REC %5d (REC delta %5d) : PLAY %5d, PLAY/REC diff %5d %s\r", recordpos, recorddelta, playpos, (int)smootheddelta, adjusting == 1 ? "DECREASE SPEED" : adjusting == 2 ? "INCREASE SPEED" : " ");
}
lastrecordpos = recordpos;
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound1, *sound2, *sound3;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key;
unsigned int version;
void *buff = 0;
int length = 0;
FMOD_CREATESOUNDEXINFO exinfo;
/*
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);
LoadFileIntoMemory("../media/drumloop.wav", &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_HARDWARE | FMOD_OPENMEMORY, &exinfo, &sound1);
ERRCHECK(result);
result = sound1->setMode(FMOD_LOOP_OFF);
ERRCHECK(result);
free(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
LoadFileIntoMemory("../media/jaguar.wav", &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_SOFTWARE | FMOD_OPENMEMORY, &exinfo, &sound2);
ERRCHECK(result);
free(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
LoadFileIntoMemory("../media/swish.wav", &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = system->createSound((const char *)buff, FMOD_HARDWARE | FMOD_OPENMEMORY, &exinfo, &sound3);
ERRCHECK(result);
free(buff); // don't need the original memory any more. Note! If loading as a stream, the memory must stay active so do not free it!
printf("==========================================================================\n");
printf("Load from memory example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("==========================================================================\n");
printf("\n");
printf("Press '1' to play a mono sound using hardware mixing\n");
printf("Press '2' to play a mono sound using software mixing\n");
printf("Press '3' to play a stereo sound using hardware mixing\n");
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case '1' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, false, &channel);
ERRCHECK(result);
break;
}
case '2' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound2, false, &channel);
ERRCHECK(result);
break;
}
case '3' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound3, false, &channel);
ERRCHECK(result);
break;
}
}
}
system->update();
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = 0;
bool paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
system->getChannelsPlaying(&channelsplaying);
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped", channelsplaying);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound1->release();
ERRCHECK(result);
result = sound2->release();
ERRCHECK(result);
result = sound3->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-2015.\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 = 0;
FMOD::Sound *sound = 0;
FMOD::Channel *channel = 0;
FMOD::DSP *dsplowpass = 0;
FMOD::DSP *dsphighpass = 0;
FMOD::DSP *dspecho = 0;
FMOD::DSP *dspflange = 0;
FMOD::DSP *dspdistortion = 0;
FMOD::DSP *dspchorus = 0;
FMOD::DSP *dspparameq = 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(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createSound("../media/drumloop.wav", FMOD_SOFTWARE, 0, &sound);
ERRCHECK(result);
printf("=================================================================\n");
printf("Effects Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("=================================================================\n");
printf("\n");
printf("Press SPACE to paused/unpause sound.\n");
printf("Press 1 to toggle dsplowpass effect.\n");
printf("Press 2 to toggle dsphighpass effect.\n");
printf("Press 3 to toggle dspecho effect.\n");
printf("Press 4 to toggle dspflange effect.\n");
printf("Press 5 to toggle dspdistortion effect.\n");
printf("Press 6 to toggle dspchorus effect.\n");
printf("Press 7 to toggle dspparameq effect.\n");
printf("Press 'Esc' to quit\n");
printf("\n");
result = system->playSound(FMOD_CHANNEL_FREE, sound, false, &channel);
ERRCHECK(result);
/*
Create some effects to play with.
*/
result = system->createDSPByType(FMOD_DSP_TYPE_LOWPASS, &dsplowpass);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_HIGHPASS, &dsphighpass);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_ECHO, &dspecho);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_FLANGE, &dspflange);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_DISTORTION, &dspdistortion);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_CHORUS, &dspchorus);
ERRCHECK(result);
result = system->createDSPByType(FMOD_DSP_TYPE_PARAMEQ, &dspparameq);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
ERRCHECK(result);
paused = !paused;
result = channel->setPaused(paused);
ERRCHECK(result);
break;
}
case '1' :
{
bool active;
result = dsplowpass->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dsplowpass->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dsplowpass, 0);
ERRCHECK(result);
}
break;
}
case '2' :
{
bool active;
result = dsphighpass->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dsphighpass->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dsphighpass, 0);
ERRCHECK(result);
}
break;
}
case '3' :
{
bool active;
result = dspecho->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dspecho->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dspecho, 0);
ERRCHECK(result);
result = dspecho->setParameter(FMOD_DSP_ECHO_DELAY, 50.0f);
ERRCHECK(result);
}
break;
}
case '4' :
{
bool active;
result = dspflange->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dspflange->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dspflange, 0);
ERRCHECK(result);
}
break;
}
case '5' :
{
bool active;
result = dspdistortion->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dspdistortion->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dspdistortion, 0);
ERRCHECK(result);
result = dspdistortion->setParameter(FMOD_DSP_DISTORTION_LEVEL, 0.8f);
ERRCHECK(result);
}
break;
}
case '6' :
{
bool active;
result = dspchorus->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dspchorus->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dspchorus, 0);
ERRCHECK(result);
}
break;
}
case '7' :
{
bool active;
result = dspparameq->getActive(&active);
ERRCHECK(result);
if (active)
{
result = dspparameq->remove();
ERRCHECK(result);
}
else
{
result = system->addDSP(dspparameq, 0);
ERRCHECK(result);
result = dspparameq->setParameter(FMOD_DSP_PARAMEQ_CENTER, 5000.0f);
ERRCHECK(result);
result = dspparameq->setParameter(FMOD_DSP_PARAMEQ_GAIN, 0.0f);
ERRCHECK(result);
}
break;
}
}
}
system->update();
{
bool paused = 0;
bool dsplowpass_active;
bool dsphighpass_active;
bool dspecho_active;
bool dspflange_active;
bool dspdistortion_active;
bool dspchorus_active;
bool dspparameq_active;
dsplowpass ->getActive(&dsplowpass_active);
dsphighpass ->getActive(&dsphighpass_active);
dspecho ->getActive(&dspecho_active);
dspflange ->getActive(&dspflange_active);
dspdistortion->getActive(&dspdistortion_active);
dspchorus ->getActive(&dspchorus_active);
dspparameq ->getActive(&dspparameq_active);
if (channel)
{
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
printf("%s : lowpass[%c] highpass[%c] echo[%c] flange[%c] dist[%c] chorus[%c] parameq[%c]\r",
paused ? "Paused " : "Playing",
dsplowpass_active ? 'x' : ' ',
dsphighpass_active ? 'x' : ' ',
dspecho_active ? 'x' : ' ',
dspflange_active ? 'x' : ' ',
dspdistortion_active ? 'x' : ' ',
dspchorus_active ? 'x' : ' ',
dspparameq_active ? 'x' : ' ');
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_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-2015.\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 audioMultiPlayer::playSound(string songPath, string songName, bool firstStart, pthread_mutex_t* mut) {
int key;
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&system);
utilities::ERRCHECK(result);
result = system->setOutput(FMOD_OUTPUTTYPE_ALSA);
utilities::ERRCHECK(result);
result = system->init(32, FMOD_INIT_NORMAL, 0);
utilities::ERRCHECK(result);
/* INIT SONG */
result = system->createSound(songPath.c_str(), FMOD_SOFTWARE, 0, &sound1);
utilities::ERRCHECK(result);
if (firstStart) {
printf("===================================================================\n");
printf("Lecteur Audio (Mix)\n");
printf("===================================================================\n");
printf("1) %s\n", songName.c_str());
} else if (!firstStart) {
sleep(1);
printf("2) %s\n", songName.c_str());
printf("===================================================================\n");
printf("\n");
printf("'Space' -> FadIn/FadOut\n");
printf("'Esc' -> Quitter\n");
printf("\n");
}
/* PLAY SONG */
result = system->playSound(FMOD_CHANNEL_FREE, sound1, 0, &channel);
utilities::ERRCHECK(result);
if(!firstStart) {
channel->setVolume(0.0f);
playPause();
}
do {
//FADIN
if (flagFadIn) {
float volume;
channel->getVolume(&volume);
channel->setVolume(volume + 0.0005f);
usleep(1000);
if (volume == 1.0f) {
flagFadIn = false;
pthread_mutex_unlock(mut);
if (firstStart) {
printf("FadIn finish for first song (mutex unlock)\n");
} else {
printf("FadIn finish for second song (mutex unlock)\n");
}
fflush(stdout);
}
}
//FADOUT
if (flagFadOut) {
float volume;
channel->getVolume(&volume);
channel->setVolume(volume - 0.0005f);
usleep(1000);
if (volume == 0.0f) {
flagFadOut = false;
playPause();
ualarm(1,0);
if (firstStart) {
printf("FadOut finish for first song\n");
} else {
printf("FadOut finish for second song\n");
}
fflush(stdout);
}
}
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = 0;
bool paused = 0;
if (channel) {
FMOD::Sound *currentsound = 0;
result = channel->isPlaying(&playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN)) {
utilities::ERRCHECK(result);
}
result = channel->getPaused(&paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN)) {
utilities::ERRCHECK(result);
}
result = channel->getPosition(&ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN)) {
utilities::ERRCHECK(result);
}
channel->getCurrentSound(¤tsound);
if (currentsound) {
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN)) {
utilities::ERRCHECK(result);
}
}
}
}
} while (key != 27);
printf("\n");
release();
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
FMOD_MODE mode = FMOD_2D | FMOD_OPENUSER | FMOD_HARDWARE | FMOD_CREATESTREAM ;
int key;
int channels = 2;
FMOD_CREATESOUNDEXINFO createsoundexinfo;
unsigned int version;
/* Initialisation du moteur audio */
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);
/* Choix de la question */
printf("Numéro de question (ou toute autre touche pour quitter) : \n");
key = getch();
if (key != '1' && key !='6')
{
return 0 ;
}
printf("%d\n",key-48) ;
/* Création d'un buffer circulaire */
memset(&createsoundexinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
createsoundexinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
createsoundexinfo.decodebuffersize = 3000;
createsoundexinfo.length = 44100 * channels * sizeof(signed short) * 5;
createsoundexinfo.numchannels = channels;
createsoundexinfo.defaultfrequency = 44100;
createsoundexinfo.format = FMOD_SOUND_FORMAT_PCM16;
createsoundexinfo.pcmsetposcallback = pcmsetposcallback;
if (key == '1')
{
mode |= FMOD_LOOP_NORMAL ;
createsoundexinfo.pcmreadcallback = cb_question1;
}
else if (key == '6')
{
mode |= FMOD_LOOP_OFF ;
createsoundexinfo.pcmreadcallback = cb_globale;
}
result = system->createSound(0, mode, &createsoundexinfo, &sound);
ERRCHECK(result);
/* Lecture du buffer */
printf("Espace = pause, Echap = quitter\n");
result = system->playSound(FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
/* Boucle principale */
do
{
/* Lecture des commandes de l'utilisateur pendant la lecture
et définition des changements à appliquer */
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
bool paused;
channel->getPaused(&paused);
channel->setPaused(!paused);
break;
}
/* QUESTION 2 */
case '*' :
{
ampGauche /= 2.0f;
ampDroite /= 2.0f;
break;
}
case '/' :
{
ampGauche *= 2.0f;
ampDroite *= 2.0f;
break;
}
case '+' :
{
freq += 10.0f;
break;
}
case '-' :
{
freq -= 10.0f;
break;
}
case '>' :
{
ampGauche /= 2.0f;
ampDroite *= 2.0f;
break;
}
case '<' :
{
ampGauche *= 2.0f;
ampDroite /= 2.0f;
break;
}
case 'g' :
{
distorsion+=100;
break;
}
case 'd' :
{
distorsion-=100;
break;
}
}
}
/* Application des changements */
system->update();
/* Récupération et affichage de l'état de la lecture (en pause, arrêté, etc.) */
if (channel)
{
unsigned int ms;
unsigned int lenms;
bool playing;
bool paused;
result = 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("Temps %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 ? "Pause " : playing ? "Lecture" : "Arret ");
fflush(stdout);
}
Sleep(20);
}
while (key != 27);
printf("\n");
/* Libération et fermeture du système audio */
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 *fsb;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
int key, count, numsubsounds;
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(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createSound("../media/example.fsb", FMOD_DEFAULT, 0, &fsb);
ERRCHECK(result);
printf("===================================================================\n");
printf("FSB Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("===================================================================\n");
printf("\n");
result = fsb->getNumSubSounds(&numsubsounds);
ERRCHECK(result);
for (count = 0; count < numsubsounds; count++)
{
FMOD::Sound *subsound;
char name[256];
result = fsb->getSubSound(count, &subsound);
ERRCHECK(result);
result = subsound->getName(name, 256);
ERRCHECK(result);
printf("Press '%c' to play \"%s\"\n", '1' + count, name);
}
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
if (key >= '1' && key < '1' + numsubsounds)
{
FMOD::Sound *subsound;
int index = key - '1';
fsb->getSubSound(index, &subsound);
result = system->playSound(FMOD_CHANNEL_FREE, subsound, false, &channel);
ERRCHECK(result);
}
}
system->update();
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = 0;
bool paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
system->getChannelsPlaying(&channelsplaying);
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped", channelsplaying);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = fsb->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 *sound1, *sound2;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
FMOD_SPEAKERMODE speakermode;
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;
}
/*
Choose the speaker mode selected by the Windows control panel.
*/
result = system->getDriverCaps(0, 0, 0, &speakermode);
ERRCHECK(result);
result = system->setSpeakerMode(speakermode);
ERRCHECK(result);
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = system->createSound("../media/drumloop.wav", FMOD_SOFTWARE | FMOD_2D, 0, &sound1);
ERRCHECK(result);
result = sound1->setMode(FMOD_LOOP_OFF);
ERRCHECK(result);
result = system->createSound("../media/stereo.ogg", FMOD_SOFTWARE | FMOD_2D, 0, &sound2);
ERRCHECK(result);
printf("==============================================================================\n");
printf("Multi Speaker Output Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("==============================================================================\n");
printf("\n");
switch (speakermode)
{
case FMOD_SPEAKERMODE_MONO :
{
printf("Using control panel speaker mode : MONO.\n");
printf("\n");
printf("Note! This output mode is very limited in its capability.\n");
printf("Most functionality of this demo is only realized with at least FMOD_SPEAKERMODE_QUAD\n");
printf("and above.\n");
break;
}
case FMOD_SPEAKERMODE_STEREO :
{
printf("Using control panel speaker mode : STEREO.\n");
printf("\n");
printf("Note! This output mode is very limited in its capability.\n");
printf("Most functionality of this demo is only realized with FMOD_SPEAKERMODE_QUAD\n");
printf("and above.\n");
break;
}
case FMOD_SPEAKERMODE_QUAD :
{
printf("Using control panel speaker mode : QUAD.\n");
printf("Side left, side right, center and subwoofer mix will be disabled.\n");
break;
}
case FMOD_SPEAKERMODE_SURROUND :
{
printf("Using control panel speaker mode : SURROUND.\n");
printf("Side left, side right and subwoofer mix will be disabled.\n");
break;
}
case FMOD_SPEAKERMODE_5POINT1 :
{
printf("Using control panel speaker mode : 5.1 surround.\n");
printf("Side left and right mix will be disabled..\n");
break;
}
case FMOD_SPEAKERMODE_7POINT1 :
{
printf("Using control panel speaker mode : 7.1 surround.\n");
printf("Full capability.\n");
break;
}
};
printf("\n");
printf("Press '1' to play a mono sound on the FRONT LEFT speaker.\n");
printf("Press '2' to play a mono sound on the FRONT RIGHT speaker.\n");
if (speakermode >= FMOD_SPEAKERMODE_SURROUND)
{
printf("Press '3' to play a mono sound on the CENTER speaker.\n");
}
else
{
printf("- CENTER Disabled\n");
}
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
printf("Press '4' to play a mono sound on the REAR LEFT speaker.\n");
printf("Press '5' to play a mono sound on the REAR RIGHT speaker.\n");
}
else
{
printf("- REAR LEFT Disabled\n");
printf("- REAR RIGHT Disabled\n");
}
if (speakermode >= FMOD_SPEAKERMODE_7POINT1)
{
printf("Press '6' to play a mono sound on the SIDE LEFT speaker.\n");
printf("Press '7' to play a mono sound on the SIDE RIGHT speaker.\n");
}
else
{
printf("- SIDE LEFT Disabled\n");
printf("- SIDE RIGHT Disabled\n");
}
printf("\n");
printf("Press '8' to play a stereo sound on the front speakers.\n");
printf("Press '9' to play a stereo sound on the front speakers but channel swapped.\n");
if (speakermode >= FMOD_SPEAKERMODE_SURROUND)
{
printf("Press '0' to play the right part of a stereo sound on the CENTER speaker.\n");
}
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case '1' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(1.0f, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
break;
}
case '2' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 1.0f, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
break;
}
case '3' :
{
if (speakermode >= FMOD_SPEAKERMODE_SURROUND) /* All formats that have a center speaker. */
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 0, 1.0f, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
case '4' :
{
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 0, 0, 0, 1.0f, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
case '5' :
{
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 0, 0, 0, 0, 1.0f, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
case '6' :
{
if (speakermode >= FMOD_SPEAKERMODE_7POINT1)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 0, 0, 0, 0, 0, 1.0f, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
case '7' :
{
if (speakermode >= FMOD_SPEAKERMODE_7POINT1)
{
result = system->playSound(FMOD_CHANNEL_FREE, sound1, true, &channel);
ERRCHECK(result);
result = channel->setSpeakerMix(0, 0, 0, 0, 0, 0, 0, 1.0f);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
case '8' :
{
float levels[2] = { 0, 1.0f };
result = system->playSound(FMOD_CHANNEL_FREE, sound2, true, &channel);
ERRCHECK(result);
/*
By default a stereo sound would play in all right and all left speakers, so this forces it to just the front.
*/
result = channel->setSpeakerMix(1.0f, 1.0f, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
break;
}
case '9' :
{
result = system->playSound(FMOD_CHANNEL_FREE, sound2, true, &channel);
ERRCHECK(result);
/*
Clear out all speakers first.
*/
result = channel->setSpeakerMix(0, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
/*
Put the left channel of the sound in the right speaker.
*/
{
float levels[2] = { 0, 1.0f }; /* This array represents the source stereo sound. l/r */
result = channel->setSpeakerLevels(FMOD_SPEAKER_FRONT_LEFT, levels, 2);
ERRCHECK(result);
}
/*
Put the right channel of the sound in the left speaker.
*/
{
float levels[2] = { 1.0f, 0 }; /* This array represents the source stereo sound. l/r */
result = channel->setSpeakerLevels(FMOD_SPEAKER_FRONT_RIGHT, levels, 2);
ERRCHECK(result);
}
result = channel->setPaused(false);
ERRCHECK(result);
break;
}
case '0' :
{
if (speakermode >= FMOD_SPEAKERMODE_SURROUND) /* All formats that have a center speaker. */
{
result = system->playSound(FMOD_CHANNEL_FREE, sound2, true, &channel);
ERRCHECK(result);
/*
Clear out all speakers first.
*/
result = channel->setSpeakerMix(0, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
/*
Put the left channel of the sound in the right speaker.
*/
{
float levels[2] = { 0, 1.0f }; /* This array represents the source stereo sound. l/r */
result = channel->setSpeakerLevels(FMOD_SPEAKER_FRONT_CENTER, levels, 2);
ERRCHECK(result);
}
result = channel->setPaused(false);
ERRCHECK(result);
}
break;
}
}
}
system->update();
{
unsigned int ms = 0;
unsigned int lenms = 0;
bool playing = false;
bool paused = false;
int channelsplaying = 0;
if (channel)
{
FMOD::Sound *currentsound = 0;
result = 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);
}
channel->getCurrentSound(¤tsound);
if (currentsound)
{
result = currentsound->getLength(&lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
system->getChannelsPlaying(&channelsplaying);
printf("Time %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : playing ? "Playing" : "Stopped", channelsplaying);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound1->release();
ERRCHECK(result);
result = sound2->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::EventSystem *eventsystem = 0;
FMOD::System *system = 0;
void *project_mem = 0;
unsigned int project_len = 0;
FMOD::Event *sampleevent = 0;
FMOD::Sound *samplebank = 0;
void *samplebank_mem = 0;
unsigned int samplebank_len = 0;
FMOD::Event *streamevent = 0;
FMOD::Sound *streambank = 0;
FMOD_RESULT result = FMOD_OK;
int key = 0;
printf("======================================================================\n");
printf("Load Event Data Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("==============================-------=================================\n");
printf("This Demonstrates loading all resources from memory allocated and filled\n");
printf("by the user.\n");
printf("======================================================================\n\n");
/* Load FEV file into memory */
loadFileIntoMemory("..\\media\\examples.fev", &project_mem, &project_len);
ERRCHECK(result = FMOD::EventSystem_Create(&eventsystem));
ERRCHECK(result = eventsystem->getSystemObject(&system));
ERRCHECK(result = eventsystem->init(64, FMOD_INIT_NORMAL, 0, FMOD_EVENT_INIT_NORMAL));
ERRCHECK(result = eventsystem->setMediaPath("..\\media\\"));
/* we require a loadinfo struct to tell FMOD how big the in memory FEV file is */
FMOD_EVENT_LOADINFO load_info;
memset(&load_info, 0, sizeof(FMOD_EVENT_LOADINFO));
load_info.size = sizeof(FMOD_EVENT_LOADINFO);
load_info.loadfrommemory_length = project_len;
/* load the project from memory */
ERRCHECK(result = eventsystem->load((char*)project_mem, &load_info, NULL));
printf("======================================================================\n");
printf("Press 'e' to load sample data\n");
printf("Press 'E' to unload sample data\n");
printf("Press 'd' to start sample event\n");
printf("Press 'w' to open stream\n");
printf("Press 'W' to close stream\n");
printf("Press 's' to start stream event\n");
printf("Press ESC to quit\n");
printf("======================================================================\n");
key = 0;
do
{
if (_kbhit())
{
key = _getch();
if (key == 'e')
{
/* Attempt to get the event without disk access */
result = eventsystem->getEvent("examples/FeatureDemonstration/Basics/SimpleEvent", FMOD_EVENT_ERROR_ON_DISKACCESS, &sampleevent);
if (result != FMOD_ERR_FILE_UNWANTED)
{
ERRCHECK(result);
}
else
{
/* file unwanted error tells us we haven't got the soundbank preloaded, so preload it now... */
printf("Loading event data\n");
loadFileIntoMemory("..\\media\\tutorial_bank.fsb", &samplebank_mem, &samplebank_len);
/* We need to create a FMOD::Sound object to use with preloadFSB */
FMOD_CREATESOUNDEXINFO info = {0};
info.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
info.length = samplebank_len;
ERRCHECK(result = system->createSound((char*)samplebank_mem, FMOD_OPENMEMORY_POINT | FMOD_CREATECOMPRESSEDSAMPLE, &info, &samplebank));
/* Tell FMOD that we have loaded this FSB */
ERRCHECK(result = eventsystem->preloadFSB("tutorial_bank.fsb", 0, samplebank));
/* Now we can get the event without diskaccess */
ERRCHECK(result = eventsystem->getEvent("examples/FeatureDemonstration/Basics/SimpleEvent", FMOD_EVENT_ERROR_ON_DISKACCESS, &sampleevent));
}
printf("Sample event ready\n");
}
else if (key == 'E')
{
if (!samplebank)
{
printf("Nothing to unload\n");
}
else
{
ERRCHECK(result = sampleevent->stop());
sampleevent = 0;
/* Note: we *MUST* call unload before freeing data */
ERRCHECK(result = eventsystem->unloadFSB("tutorial_bank.fsb", 0));
ERRCHECK(result = samplebank->release());
samplebank = 0;
if (samplebank_mem)
{
free(samplebank_mem);
samplebank_mem = 0;
}
printf("Event data unloaded\n");
}
}
else if (key == 'd')
{
if (!sampleevent)
{
printf("no event loaded!\n");
}
else
{
ERRCHECK(result = sampleevent->start());
}
}
else if (key == 'w')
{
/* Attempt to get the event without opening a new stream */
result = eventsystem->getEvent("examples/AdvancedTechniques/MultiChannelMusic", FMOD_EVENT_ERROR_ON_DISKACCESS, &streamevent);
if (result != FMOD_ERR_FILE_UNWANTED)
{
ERRCHECK(result);
}
else
{
/* file unwanted error tells us we haven't got the stream instance preloaded so preload it now */
printf("Opening stream\n");
/* If the 'Max Streams' property of the sound bank is greater than 1 then mutiple streams can be opened. This means we need
to preload it multiple times if we want to prevent FMOD from creating streams internally. Each stream is uniquely identified
using the 'streaminstance' parameter to preloadFSB which counts upwards from 0.
*/
ERRCHECK(result = system->createSound("..\\media\\streaming_bank.fsb", FMOD_CREATESTREAM, 0, &streambank));
ERRCHECK(result = eventsystem->preloadFSB("streaming_bank.fsb", 0, streambank));
/* Now we can get the event without opening a new stream */
ERRCHECK(result = eventsystem->getEvent("examples/AdvancedTechniques/MultiChannelMusic", FMOD_EVENT_ERROR_ON_DISKACCESS, &streamevent));
}
printf("Stream event ready\n");
}
else if (key == 'W')
{
if (!streambank)
{
printf("Nothing to unload\n");
}
else
{
ERRCHECK(result = streamevent->stop());
streamevent = 0;
/* Note: we *MUST* call unload before releasing stream */
ERRCHECK(result = eventsystem->unloadFSB("streaming_bank.fsb", 0));
ERRCHECK(result = streambank->release());
streambank = 0;
printf("Stream closed\n");
}
}
else if (key == 's')
{
if (!streamevent)
{
printf("no event loaded!\n");
}
else
{
ERRCHECK(result = streamevent->start());
}
}
}
ERRCHECK(result = eventsystem->update());
Sleep(15);
} while (key != 27);
if (samplebank)
{
/* Note: we *MUST* call unload before freeing data */
ERRCHECK(result = eventsystem->unloadFSB("tutorial_bank.fsb", 0));
ERRCHECK(result = samplebank->release());
if (samplebank_mem)
{
free(samplebank_mem);
}
}
if (streambank)
{
/* Note: we *MUST* call unload before releasing stream */
ERRCHECK(result = eventsystem->unloadFSB("streaming_bank.fsb", 0));
ERRCHECK(result = streambank->release());
}
ERRCHECK(result = eventsystem->release());
/* Free the memory we have allocated */
free(project_mem);
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-2015.\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 *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-2011.\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 FMOD_Main()
{
FMOD::System *system = 0;
FMOD::Sound *sound = 0;
FMOD::Channel *channel = 0;
FMOD_RESULT result = FMOD_OK;
FMOD_OPENSTATE openstate = FMOD_OPENSTATE_READY;
unsigned int version = 0;
void *extradriverdata = 0;
const int tagcount = 4;
int tagindex = 0;
char tagstring[tagcount][128] = { 0 };
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(1, FMOD_INIT_NORMAL, extradriverdata);
ERRCHECK(result);
/* Increase the file buffer size a little bit to account for Internet lag. */
result = system->setStreamBufferSize(64*1024, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
result = system->createSound("http://shoutmedia.abc.net.au:10426", FMOD_CREATESTREAM | FMOD_NONBLOCKING, 0, &sound);
ERRCHECK(result);
/*
Main loop
*/
do
{
unsigned int pos = 0;
unsigned int percent = 0;
bool playing = false;
bool paused = false;
bool starving = false;
const char *state = "Stopped";
Common_Update();
if (Common_BtnPress(BTN_ACTION1))
{
if (channel)
{
bool paused = false;
result = channel->getPaused(&paused);
ERRCHECK(result);
result = channel->setPaused(!paused);
ERRCHECK(result);
}
}
result = system->update();
ERRCHECK(result);
result = sound->getOpenState(&openstate, &percent, &starving, 0);
ERRCHECK(result);
if (channel)
{
FMOD_TAG tag;
/*
Read any tags that have arrived, this could happen if a radio station switches
to a new song.
*/
while (sound->getTag(0, -1, &tag) == FMOD_OK)
{
if (tag.datatype == FMOD_TAGDATATYPE_STRING)
{
sprintf(tagstring[tagindex], "%s = '%s' (%d bytes)", tag.name, (char *)tag.data, tag.datalen);
tagindex = (tagindex + 1) % tagcount;
}
else if (tag.type == FMOD_TAGTYPE_FMOD)
{
/* When a song changes, the sample rate may also change, so compensate here. */
if (!strcmp(tag.name, "Sample Rate Change"))
{
float frequency = *((float *)tag.data);
result = channel->setFrequency(frequency);
ERRCHECK(result);
}
}
}
result = channel->getPaused(&paused);
ERRCHECK(result);
result = channel->isPlaying(&playing);
ERRCHECK(result);
result = channel->getPosition(&pos, FMOD_TIMEUNIT_MS);
ERRCHECK(result);
/* Silence the stream until we have sufficient data for smooth playback. */
result = channel->setMute(starving);
ERRCHECK(result);
}
else
{
/* This may fail if the stream isn't ready yet, so don't check the error code. */
system->playSound(sound, 0, false, &channel);
}
if (openstate == FMOD_OPENSTATE_BUFFERING)
{
state = "Buffering...";
}
else if (openstate == FMOD_OPENSTATE_CONNECTING)
{
state = "Connecting...";
}
else if (paused)
{
state = "Paused";
}
else if (playing)
{
state = "Playing";
}
Common_Draw("==================================================");
Common_Draw("Net Stream Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2014.");
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", pos / 1000 / 60, pos / 1000 % 60, pos / 10 % 100);
Common_Draw("State = %s %s", state, starving ? "(STARVING)" : "");
Common_Draw("Buffer Percentage = %d", percent);
Common_Draw("");
Common_Draw("Tags:");
for (int i = tagindex; i < (tagindex + tagcount); i++)
{
Common_Draw("%s", tagstring[i % tagcount]);
Common_Draw("");
}
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Stop the channel, then wait for it to finish opening before we release it.
*/
if (channel)
{
result = channel->stop();
ERRCHECK(result);
}
do
{
Common_Update();
Common_Draw("Waiting for sound to finish opening before trying to release it....", Common_BtnStr(BTN_ACTION1));
Common_Sleep(50);
result = system->update();
ERRCHECK(result);
result = sound->getOpenState(&openstate, 0, 0, 0);
ERRCHECK(result);
} while (openstate != FMOD_OPENSTATE_READY);
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
Common_Close();
return 0;
}
int FMOD_Main()
{
void *extradriverdata = 0;
Common_Init(&extradriverdata);
/*
Create a System object and initialize
*/
FMOD_RESULT result;
FMOD::System* system;
result = FMOD::System_Create(&system);
ERRCHECK(result);
unsigned int version;
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);
/*
Create a new channel group to hold the convolution DSP unit
*/
FMOD::ChannelGroup* reverbGroup;
result = system->createChannelGroup("reverb", &reverbGroup);
ERRCHECK(result);
/*
Create a new channel group to hold all the channels and process the dry path
*/
FMOD::ChannelGroup* mainGroup;
result = system->createChannelGroup("main", &mainGroup);
ERRCHECK(result);
/*
Create the convultion DSP unit and set it as the tail of the channel group
*/
FMOD::DSP* reverbUnit;
result = system->createDSPByType(FMOD_DSP_TYPE_CONVOLUTIONREVERB, &reverbUnit);
ERRCHECK(result);
result = reverbGroup->addDSP(FMOD_CHANNELCONTROL_DSP_TAIL, reverbUnit);
ERRCHECK(result);
/*
Open the impulse response wav file, but use FMOD_OPENONLY as we want
to read the data into a seperate buffer
*/
FMOD::Sound* irSound;
result = system->createSound(Common_MediaPath("standrews.wav"), FMOD_DEFAULT | FMOD_OPENONLY, NULL, &irSound);
ERRCHECK(result);
/*
Retrieve the sound information for the Impulse Response input file
*/
FMOD_SOUND_FORMAT irSoundFormat;
FMOD_SOUND_TYPE irSoundType;
int irSoundBits, irSoundChannels;
result = irSound->getFormat(&irSoundType, &irSoundFormat, &irSoundChannels, &irSoundBits);
ERRCHECK(result);
unsigned int irSoundLength;
result = irSound->getLength(&irSoundLength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
if (irSoundFormat != FMOD_SOUND_FORMAT_PCM16)
{
/*
For simplicity of the example, if the impulse response is the wrong format just display an error
*/
Common_Fatal("Impulse Response file is the wrong audio format");
}
/*
The reverb unit expects a block of data containing a single 16 bit int containing
the number of channels in the impulse response, followed by PCM 16 data
*/
unsigned int irDataLength = sizeof(short) * (irSoundLength * irSoundChannels + 1);
short* irData = (short*)malloc(irDataLength);
irData[0] = irSoundChannels;
unsigned int irDataRead;
result = irSound->readData(&irData[1], irDataLength - sizeof(short), &irDataRead);
ERRCHECK(result);
result = reverbUnit->setParameterData(FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR, irData, irDataLength);
ERRCHECK(result);
/*
Don't pass any dry signal from the reverb unit, instead take the dry part
of the mix from the main signal path
*/
result = reverbUnit->setParameterFloat(FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY, -80.0f);
ERRCHECK(result);
/*
We can now free our copy of the IR data and release the sound object, the reverb unit
has created it's internal data
*/
free(irData);
result = irSound->release();
ERRCHECK(result);
/*
Load up and play a sample clip recorded in an anechoic chamber
*/
FMOD::Sound* sound;
system->createSound(Common_MediaPath("singing.wav"), FMOD_3D | FMOD_LOOP_NORMAL, NULL, &sound);
ERRCHECK(result);
FMOD::Channel* channel;
system->playSound(sound, mainGroup, true, &channel);
ERRCHECK(result);
/*
Create a send connection between the channel head and the reverb unit
*/
FMOD::DSP* channelHead;
channel->getDSP(FMOD_CHANNELCONTROL_DSP_HEAD, &channelHead);
ERRCHECK(result);
FMOD::DSPConnection* reverbConnection;
result = reverbUnit->addInput(channelHead, &reverbConnection, FMOD_DSPCONNECTION_TYPE_SEND);
ERRCHECK(result);
result = channel->setPaused(false);
ERRCHECK(result);
float wetVolume = 1.0;
float dryVolume = 1.0;
/*
Main loop
*/
do
{
Common_Update();
if (Common_BtnPress(BTN_LEFT))
{
wetVolume = (wetVolume <= 0.0f) ? wetVolume : wetVolume - 0.05;
}
if (Common_BtnPress(BTN_RIGHT))
{
wetVolume = (wetVolume >= 1.0f) ? wetVolume : wetVolume + 0.05f;
}
if (Common_BtnPress(BTN_DOWN))
{
dryVolume = (dryVolume <= 0.0f) ? dryVolume : dryVolume - 0.05f;
}
if (Common_BtnPress(BTN_UP))
{
dryVolume = (dryVolume >= 1.0f) ? dryVolume : dryVolume + 0.05f;
}
result = system->update();
ERRCHECK(result);
result = reverbConnection->setMix(wetVolume);
ERRCHECK(result);
result = mainGroup->setVolume(dryVolume);
ERRCHECK(result);
Common_Draw("==================================================");
Common_Draw("Convolution Example.");
Common_Draw("Copyright (c) Firelight Technologies 2004-2015.");
Common_Draw("==================================================");
Common_Draw("Press %s and %s to change dry mix", Common_BtnStr(BTN_UP), Common_BtnStr(BTN_DOWN));
Common_Draw("Press %s and %s to change wet mix", Common_BtnStr(BTN_LEFT), Common_BtnStr(BTN_RIGHT));
Common_Draw("wet mix [%.2f] dry mix [%.2f]", wetVolume, dryVolume);
Common_Draw("Press %s to quit", Common_BtnStr(BTN_QUIT));
Common_Draw("");
Common_Sleep(50);
} while (!Common_BtnPress(BTN_QUIT));
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = mainGroup->release();
ERRCHECK(result);
result = reverbGroup->removeDSP(reverbUnit);
ERRCHECK(result);
result = reverbUnit->disconnectAll(true, true);
ERRCHECK(result);
result = reverbUnit->release();
ERRCHECK(result);
result = reverbGroup->release();
ERRCHECK(result);
result = system->close();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
Common_Close();
return 0;
}
void FMODVoiceAdapter::UpdateSound(bool isRec)
{
FMOD_RESULT fmodErr;
unsigned int soundLength;
const int sampleSize = 2;
FMOD::Sound *snd = (isRec) ? recSound : sound;
unsigned int& lastPos = (isRec) ? lastRecordingPos : lastPlayPos;
// get current Play or recording position
unsigned int currPos;
if (isRec){
fmodErr=fmodSystem->getRecordPosition(0,&currPos);
RakAssert(fmodErr==FMOD_OK);
} else {
fmodErr=channel->getPosition(&currPos, FMOD_TIMEUNIT_PCM);
RakAssert(fmodErr==FMOD_OK);
}
// Get length of sound in samples
fmodErr=snd->getLength(&soundLength, FMOD_TIMEUNIT_PCM);
RakAssert(fmodErr==FMOD_OK);
// calculate some variables we'll need ahead
int bufferSizeBytes = rakVoice->GetBufferSizeBytes();
// Round down the current position to a multiple of buffer size in samples
currPos -= currPos % (bufferSizeBytes/sampleSize);
if ( ((!isRec)||(isRec && !mute)) && (currPos != lastPos) )
{
void *ptr1, *ptr2;
unsigned int len1, len2;
int blockLength;
blockLength = (int)currPos - (int)lastPos;
// Check for wrap around, and adjust
if (blockLength < 0)
{
blockLength += soundLength;
}
// Lock to get access to the raw data
snd->lock(lastPos * sampleSize, blockLength * sampleSize, &ptr1, &ptr2, &len1, &len2);
// Since the length and current position are both a multiple of bufferSizeBytes
// just treat treat one full buffer at a time
int numFrames = len1 / bufferSizeBytes;
while(numFrames--){
if (isRec) {
BroadcastFrame(ptr1);
} else {
rakVoice->ReceiveFrame(ptr1);
}
ptr1 = (char*)ptr1 + bufferSizeBytes;
}
numFrames = len2 / bufferSizeBytes;
while(numFrames--) {
if (isRec){
BroadcastFrame(ptr2);
} else {
rakVoice->ReceiveFrame(ptr2);
}
ptr2 = (char*)ptr2 + bufferSizeBytes;
}
snd->unlock(ptr1, ptr2, len1, len2);
}
lastPos = currPos;
}
int PitchDetector::DetectPitch()
{
FMOD::System *system = 0;
FMOD::Sound *sound = 0;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
FMOD_CREATESOUNDEXINFO exinfo;
int key, driver, recorddriver, numdrivers, count, bin;
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(-1);
}
/*
System initialization
*/
printf("---------------------------------------------------------\n");
printf("Select OUTPUT type\n");
printf("---------------------------------------------------------\n");
printf("1 : DirectSound\n");
printf("2 : Windows Multimedia WaveOut\n");
printf("3 : ASIO\n");
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
//key = _getch();
key = '1'; //TODO: this uses the default io device rather than using user input
} while (key != 27 && key < '1' && key > '5');
switch (key)
{
case '1' : result = system->setOutput(FMOD_OUTPUTTYPE_DSOUND);
break;
case '2' : result = system->setOutput(FMOD_OUTPUTTYPE_WINMM);
break;
case '3' : result = system->setOutput(FMOD_OUTPUTTYPE_ASIO);
break;
default : return(0);
}
ERRCHECK(result);
/*
Enumerate playback devices
*/
result = system->getNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a PLAYBACK driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
//key = _getch();
key = '1'; //TODO: io devices
if (key == 27)
{
return(0);
}
driver = key - '1';
} while (driver < 0 || driver >= numdrivers);
result = system->setDriver(driver);
ERRCHECK(result);
/*
Enumerate record devices
*/
result = system->getRecordNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getRecordDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
recorddriver = 0;
do
{
//key = _getch();
key = '1'; //TODO: io devices
if (key == 27)
{
return(0);
}
recorddriver = key - '1';
} while (recorddriver < 0 || recorddriver >= numdrivers);
printf("\n");
result = system->setSoftwareFormat(OUTPUT_RATE, FMOD_SOUND_FORMAT_PCM16, 1, 0, FMOD_DSP_RESAMPLER_LINEAR);
ERRCHECK(result);
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
/*
Create a sound to record to.
*/
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 1;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.defaultfrequency = OUTPUT_RATE;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 5;
result = system->createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_LOOP_NORMAL | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
/*
Start the interface
*/
printf("=========================================================================\n");
printf("Pitch detection example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("=========================================================================\n");
printf("\n");
printf("Record something through the selected recording device and FMOD will\n");
printf("Determine the pitch. Sustain the tone for at least a second to get an\n");
printf("accurate reading.\n");
printf("Press 'Esc' to quit\n");
printf("\n");
result = system->recordStart(recorddriver, sound, true);
ERRCHECK(result);
Sleep(100); /* Give it some time to record something */
result = system->playSound(FMOD_CHANNEL_REUSE, sound, false, &channel);
ERRCHECK(result);
/* Dont hear what is being recorded otherwise it will feedback. Spectrum analysis is done before volume scaling in the DSP chain */
result = channel->setVolume(0);
ERRCHECK(result);
bin = 0;
/*
Main loop.
*/
do
{
static float spectrum[SPECTRUM_SIZE];
float dominantHz = 0;
float max;
int dominantNote = 0;
float binSize = BIN_SIZE;
bool hasUpdated = false;
char windowTitle[sizeof("Pitch Detector: ---")] = "Pitch Detector: ---";
int noteIndex;
double noteDeviation;
if (_kbhit())
{
key = _getch();
}
result = channel->getSpectrum(spectrum, SPECTRUM_SIZE, 0, FMOD_DSP_FFT_WINDOW_TRIANGLE);
ERRCHECK(result);
max = 0;
for (count = 0; count < SPECTRUM_SIZE; count++)
{
if (spectrum[count] > 0.01f && spectrum[count] > max)
{
max = spectrum[count];
bin = count;
hasUpdated = true;
}
}
dominantHz = (float)bin * BIN_SIZE; /* dominant frequency min */
dominantNote = 0;
for (count = 0; count < 120; count++)
{
if (dominantHz >= noteFreq[count] && dominantHz < noteFreq[count + 1])
{
/* which is it closer to. This note or the next note */
if (fabs(dominantHz - noteFreq[count]) < fabs(dominantHz - noteFreq[count+1]))
{
dominantNote = count;
}
else
{
dominantNote = count + 1;
}
break;
}
}
printf("Detected rate : %7.1f -> %7.1f hz. Detected musical note. %-3s (%7.1f hz)\r",
dominantHz, ((float)bin + 0.99f) * BIN_SIZE, note[dominantNote], noteFreq[dominantNote]);
// Sets the window title to Pitch Detector: (NOTE)(#|)([0-9]) \| (KEY_MAPPING)
string noteStr = note[dominantNote];
noteStr = noteStr[0];
string keyMapping = " | " + mappingsInterface->GetBoxText(noteStr);
strncpy(windowTitle + sizeof("Pitch Detector: ") - 1, note[dominantNote], 3);
if (!hasUpdated)
{
strncpy(windowTitle + sizeof("Pitch Detector: ") - 1, "---", 3);
keyMapping = "";
}
string windowTitleStr = windowTitle;
emit UpdateTitleSignal(QString((windowTitleStr + keyMapping).c_str()));
// Sets the feedback of what note is being played
if (!hasUpdated)
{
noteIndex = -1;
noteDeviation = 0;
}
else
{
noteIndex = NoteToIndex(dominantNote);
noteDeviation = GetNoteDeviation(dominantHz, dominantNote);
}
emit UpdateNoteDisplaySignal(noteIndex, noteDeviation);
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
ERRCHECK(result);
result = system->release();
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD::System *system;
FMOD::Sound *sound;
FMOD_RESULT result;
FMOD_TAG tag;
int numtags, numtagsupdated, count;
unsigned int version;
printf("==================================================================\n");
printf("ReadTags Example. Copyright (c) Firelight Technologies 2004-2015.\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(100, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
/*
Open the specified file. Use FMOD_CREATESTREAM and FMOD_OPENONLY so it opens quickly
*/
result = system->createSound("../media/wave.mp3", FMOD_SOFTWARE | FMOD_2D | FMOD_CREATESTREAM | FMOD_OPENONLY, 0, &sound);
ERRCHECK(result);
/*
Read and display all tags associated with this file
*/
for (;;)
{
/*
An index of -1 means "get the first tag that's new or updated".
If no tags are new or updated then getTag will return FMOD_ERR_TAGNOTFOUND.
This is the first time we've read any tags so they'll all be new but after we've read them,
they won't be new any more.
*/
if (sound->getTag(0, -1, &tag) != FMOD_OK)
{
break;
}
if (tag.datatype == FMOD_TAGDATATYPE_STRING)
{
printf("%s = %s (%d bytes)\n", tag.name, tag.data, tag.datalen);
}
else
{
printf("%s = <binary> (%d bytes)\n", tag.name, tag.datalen);
}
}
printf("\n");
/*
Read all the tags regardless of whether they're updated or not. Also show the tag type.
*/
result = sound->getNumTags(&numtags, &numtagsupdated);
ERRCHECK(result);
for (count=0; count < numtags; count++)
{
result = sound->getTag(0, count, &tag);
ERRCHECK(result);
switch (tag.type)
{
case FMOD_TAGTYPE_UNKNOWN :
printf("FMOD_TAGTYPE_UNKNOWN ");
break;
case FMOD_TAGTYPE_ID3V1 :
printf("FMOD_TAGTYPE_ID3V1 ");
break;
case FMOD_TAGTYPE_ID3V2 :
printf("FMOD_TAGTYPE_ID3V2 ");
break;
case FMOD_TAGTYPE_VORBISCOMMENT :
printf("FMOD_TAGTYPE_VORBISCOMMENT ");
break;
case FMOD_TAGTYPE_SHOUTCAST :
printf("FMOD_TAGTYPE_SHOUTCAST ");
break;
case FMOD_TAGTYPE_ICECAST :
printf("FMOD_TAGTYPE_ICECAST ");
break;
case FMOD_TAGTYPE_ASF :
printf("FMOD_TAGTYPE_ASF ");
break;
case FMOD_TAGTYPE_FMOD :
printf("FMOD_TAGTYPE_FMOD ");
break;
case FMOD_TAGTYPE_USER :
printf("FMOD_TAGTYPE_USER ");
break;
}
if (tag.datatype == FMOD_TAGDATATYPE_STRING)
{
printf("%s = %s (%d bytes)\n", tag.name, tag.data, tag.datalen);
}
else
{
printf("%s = ??? (%d bytes)\n", tag.name, tag.datalen);
}
}
printf("\n");
/*
Find a specific tag by name. Specify an index > 0 to get access to multiple tags of the same name.
*/
result = sound->getTag("ARTIST", 0, &tag);
ERRCHECK(result);
printf("%s = %s (%d bytes)\n", tag.name, tag.data, tag.datalen);
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 = 0;
FMOD::Sound *sound = 0;
FMOD::Channel *channel = 0;
FMOD_RESULT result;
FMOD_CREATESOUNDEXINFO exinfo;
int key, driver, recorddriver, numdrivers, count;
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;
}
/*
System initialization
*/
printf("---------------------------------------------------------\n");
printf("Select OUTPUT type\n");
printf("---------------------------------------------------------\n");
printf("1 : OSS - Open Sound System\n");
printf("2 : ALSA - Advanced Linux Sound Architecture\n");
printf("3 : ESD - Enlightenment Sound Daemon\n");
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
key = getch();
} while (key != 27 && key < '1' && key > '5');
switch (key)
{
case '1' : result = system->setOutput(FMOD_OUTPUTTYPE_OSS);
break;
case '2' : result = system->setOutput(FMOD_OUTPUTTYPE_ALSA);
break;
case '3' : result = system->setOutput(FMOD_OUTPUTTYPE_ESD);
break;
default : return 1;
}
ERRCHECK(result);
/*
Enumerate playback devices
*/
result = system->getNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a PLAYBACK driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
do
{
key = getch();
if (key == 27)
{
return 0;
}
driver = key - '1';
} while (driver < 0 || driver >= numdrivers);
result = system->setDriver(driver);
ERRCHECK(result);
/*
Enumerate record devices
*/
result = system->getRecordNumDrivers(&numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = system->getRecordDriverInfo(count, name, 256, 0);
ERRCHECK(result);
printf("%d : %s\n", count + 1, name);
}
printf("---------------------------------------------------------\n");
printf("Press a corresponding number or ESC to quit\n");
recorddriver = 0;
do
{
key = getch();
if (key == 27)
{
return 0;
}
recorddriver = key - '1';
} while (recorddriver < 0 || recorddriver >= numdrivers);
printf("\n");
result = system->init(32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 1;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.defaultfrequency = 44100;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 5;
result = system->createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_OPENUSER, &exinfo, &sound);
ERRCHECK(result);
printf("===================================================================\n");
printf("Recording example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("===================================================================\n");
printf("\n");
printf("Press 'r' to record a 5 second segment of audio and write it to a wav file.\n");
printf("Press 'p' to play the 5 second segment of audio.\n");
printf("Press 'l' to turn looping on/off.\n");
printf("Press 's' to stop recording and playback.\n");
printf("Press 'w' to save the 5 second segment to a wav file.\n");
printf("Press 'Esc' to quit\n");
printf("\n");
/*
Main loop.
*/
do
{
static FMOD::Channel *channel = 0;
static bool looping = false;
bool recording = false;
bool playing = false;
unsigned int recordpos = 0;
unsigned int playpos = 0;
unsigned int length;
if (kbhit())
{
key = getch();
switch (key)
{
case 'r' :
case 'R' :
{
result = system->recordStart(recorddriver, sound, looping);
ERRCHECK(result);
break;
}
case 'p' :
case 'P' :
{
if (looping)
{
sound->setMode(FMOD_LOOP_NORMAL);
}
else
{
sound->setMode(FMOD_LOOP_OFF);
}
ERRCHECK(result);
result = system->playSound(FMOD_CHANNEL_REUSE, sound, false, &channel);
ERRCHECK(result);
break;
}
case 'l' :
case 'L' :
{
looping = !looping;
break;
}
case 's' :
case 'S' :
{
result = system->recordStop(recorddriver);
if (channel)
{
channel->stop();
channel = 0;
}
break;
}
case 'w' :
case 'W' :
{
printf("Writing to record.wav ... \r");
SaveToWav(sound);
Sleep(500);
break;
}
}
}
sound->getLength(&length, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
system->isRecording(recorddriver, &recording);
ERRCHECK(result);
system->getRecordPosition(recorddriver, &recordpos);
ERRCHECK(result);
if (channel)
{
channel->isPlaying(&playing);
ERRCHECK(result);
channel->getPosition(&playpos, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
}
printf("State: %-19s. Record pos = %6d : Play pos = %6d : Loop %-3s\r", recording ? playing ? "Recording / playing" : "Recording" : playing ? "Playing" : "Idle", recordpos, playpos, looping ? "On" : "Off");
fflush(stdout);
system->update();
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = sound->release();
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;
}
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 = gSystem->createStream(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 = gSystem->playSound(FMOD_CHANNEL_FREE, newsound, true, &newchannel);
ERRCHECK(result);
result = newchannel->setSpeakerMix(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 = playingchannel->getDelay(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 = playingchannel->getCurrentSound(&playingsound);
ERRCHECK(result);
result = playingsound->getLength(&sound_length, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
result = playingchannel->getFrequency(&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 = newchannel->setDelay(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.
*/
newchannel->getFrequency(&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 */
newchannel->setFrequency(val);
newchannel->getVolume(&val);
variation = ((float)(rand()%10000) / 10000.0f); /* 0.0 to 1.0 */
val *= (1.0f - (variation * 0.2f)); /* 0.8 to 1.0 */
newchannel->setVolume(val);
newchannel->getDelay(FMOD_DELAYTYPE_DSPCLOCK_START, &hi, &lo);
printf("new sound to start at %d (slot %d)\n", lo, slot);
}
result = newchannel->setPaused(false);
ERRCHECK(result);
return newchannel;
}
