/*
---------------------------------------
获取当前位置
---------------------------------------
*/
static bool_t
iXMM_FMOD_get_pos (
__CR_IN__ iXMMEDIA* that,
__CR_OT__ int64u* curt,
__CR_OT__ int64u* total
)
{
uint_t pos;
uint_t len;
iXMM_FMOD* real;
FMOD_RESULT result;
real = (iXMM_FMOD*)that;
if (total != NULL) {
result = FMOD_Sound_GetLength(real->m_snd, &len,
FMOD_TIMEUNIT_MS);
if (result != FMOD_OK)
return (FALSE);
*total = len;
}
if (curt != NULL) {
result = FMOD_Channel_GetPosition(real->m_chn, &pos,
FMOD_TIMEUNIT_MS);
if (result != FMOD_OK)
return (FALSE);
*curt = pos;
}
return (TRUE);
}
int fmod_getlength(int i, unsigned int *lenms)
{
FMOD_RESULT result;
result = FMOD_Sound_GetLength(sound[i], lenms, FMOD_TIMEUNIT_MS);
if (ERRCHECK(result)) return 1;
return 0;
}
int sound_length(void)
{
if (loaded) {
unsigned int mili;
FMOD_Sound_GetLength(_sound, &mili, FMOD_TIMEUNIT_MS);
return (int) mili;
}
return 0;
}
//------------------------------------------------------------
void ofMultiDeviceSoundPlayer::loadSoundWithTarget(string fileName, int deviceIndex)
{
device = deviceIndex;
bool stream = false;
fileName = ofToDataPath(fileName);
// fmod uses IO posix internally, might have trouble
// with unicode paths...
// says this code:
// http://66.102.9.104/search?q=cache:LM47mq8hytwJ:www.cleeker.com/doxygen/audioengine__fmod_8cpp-source.html+FSOUND_Sample_Load+cpp&hl=en&ct=clnk&cd=18&client=firefox-a
// for now we use FMODs way, but we could switch if
// there are problems:
bMultiPlay = false;
// [1] init fmod, if necessary
initializeFmodWithTargetDevice(deviceIndex);
// [2] try to unload any previously loaded sounds
// & prevent user-created memory leaks
// if they call "loadSound" repeatedly, for example
unloadSound();
// [3] load sound
//choose if we want streaming
int fmodFlags = FMOD_SOFTWARE;
if(stream)fmodFlags = FMOD_SOFTWARE | FMOD_CREATESTREAM;
result = FMOD_System_CreateSound(sys_Array[deviceIndex], fileName.c_str(), fmodFlags, NULL, &sound);
if (result != FMOD_OK){
bLoadedOk = false;
printf("ofSoundPlayer: Could not load sound file %s \n", fileName.c_str() );
} else {
bLoadedOk = true;
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_PCM);
isStreaming = stream;
}
}
//------------------------------------------------------------
bool ofFmodSoundPlayer::load(std::filesystem::path fileName, bool stream){
fileName = ofToDataPath(fileName);
// fmod uses IO posix internally, might have trouble
// with unicode paths...
// says this code:
// http://66.102.9.104/search?q=cache:LM47mq8hytwJ:www.cleeker.com/doxygen/audioengine__fmod_8cpp-source.html+FSOUND_Sample_Load+cpp&hl=en&ct=clnk&cd=18&client=firefox-a
// for now we use FMODs way, but we could switch if
// there are problems:
bMultiPlay = false;
// [1] init fmod, if necessary
initializeFmod();
// [2] try to unload any previously loaded sounds
// & prevent user-created memory leaks
// if they call "loadSound" repeatedly, for example
unload();
// [3] load sound
//choose if we want streaming
int fmodFlags = FMOD_SOFTWARE;
if(stream)fmodFlags = FMOD_SOFTWARE | FMOD_CREATESTREAM;
result = FMOD_System_CreateSound(sys, fileName.string().c_str(), fmodFlags, nullptr, &sound);
if (result != FMOD_OK){
bLoadedOk = false;
ofLogError("ofFmodSoundPlayer") << "loadSound(): could not load \"" << fileName << "\"";
} else {
bLoadedOk = true;
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_PCM);
isStreaming = stream;
}
return bLoadedOk;
}
unsigned int JiwokFMODWrapper::GetLength(const char *filename)
{
FMOD_SYSTEM *system;
FMOD_SOUND *sound;
FMOD_RESULT result;
unsigned int version;
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
//printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = FMOD_System_CreateStream(system,filename, FMOD_OPENONLY | FMOD_ACCURATETIME, 0, &sound);
// ERRCHECK(result);
unsigned int length = 0;
result = FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_MS);
ERRCHECK(result);
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return length;
}
/*
---------------------------------------
设置当前位置
---------------------------------------
*/
static bool_t
iXMM_FMOD_set_pos (
__CR_IN__ iXMMEDIA* that,
__CR_IN__ int64u curt
)
{
uint_t pos;
uint_t len;
iXMM_FMOD* real;
FMOD_RESULT result;
real = (iXMM_FMOD*)that;
result = FMOD_Sound_GetLength(real->m_snd, &len, FMOD_TIMEUNIT_MS);
if (result != FMOD_OK)
return (FALSE);
pos = (curt >= len) ? len : (uint_t)curt;
result = FMOD_Channel_SetPosition(real->m_chn, pos, FMOD_TIMEUNIT_MS);
if (result != FMOD_OK)
return (FALSE);
return (TRUE);
}
void musicHandler (void)
{
int playing = 0;
unsigned int ms = 0;
unsigned int lenms = 0;
if (chan)
{
result = FMOD_Channel_IsPlaying(chan, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
if (playing)
{
return;
}
FMOD_SOUND *currentsound = 0;
result = FMOD_Channel_GetPosition(chan, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_Channel_GetCurrentSound(chan, ¤tsound);
if (currentsound)
{
result = FMOD_Sound_GetLength(currentsound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
current_track = (current_track + 1) % SCNT;
playMusic(current_track);
}
jint Java_org_fmod_playsound_Example_cGetLength(JNIEnv *env, jobject thiz)
{
FMOD_RESULT result = FMOD_OK;
FMOD_SOUND *sound = 0;
int length = 0;
if (gChannel)
{
result = FMOD_Channel_GetCurrentSound(gChannel, &sound);
if (result != FMOD_ERR_INVALID_HANDLE && result != FMOD_ERR_CHANNEL_STOLEN)
{
CHECK_RESULT(result);
}
}
if (sound)
{
result = FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_MS);
CHECK_RESULT(result);
}
return length;
}
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 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 = FMOD_System_CreateStream(system, "../media/wave.mp3", FMOD_OPENONLY | FMOD_LOOP_NORMAL | FMOD_LOWMEM | FMOD_CREATESTREAM, 0, &decodesound);
ERRCHECK(result);
result = FMOD_Sound_GetLength(decodesound, &decodesound_lengthbytes, FMOD_TIMEUNIT_PCMBYTES);
ERRCHECK(result);
result = FMOD_Sound_GetFormat(decodesound, 0, 0, &decodesound_channels, 0);
ERRCHECK(result);
result = FMOD_Sound_GetDefaults(decodesound, &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 = FMOD_System_CreateStream(system, 0, FMOD_2D | FMOD_OPENUSER | FMOD_LOOP_NORMAL, &createsoundexinfo, &sound);
ERRCHECK(result);
printf("============================================================================\n");
printf("Manual Decode example. Copyright (c) Firelight Technologies 2004-2011.\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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
int paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
break;
}
case '<' :
{
unsigned int position;
FMOD_Channel_GetPosition(channel, &position, FMOD_TIMEUNIT_MS);
if (position >= 1000)
{
position -= 1000;
}
FMOD_Channel_SetPosition(channel, position, FMOD_TIMEUNIT_MS);
break;
}
case '>' :
{
unsigned int position;
FMOD_Channel_GetPosition(channel, &position, FMOD_TIMEUNIT_MS);
position += 1000;
FMOD_Channel_SetPosition(channel, position, FMOD_TIMEUNIT_MS);
break;
}
}
}
FMOD_System_Update(system);
if (channel)
{
unsigned int ms;
unsigned int lenms;
int playing;
int paused;
FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Sound_GetLength(sound, &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 = FMOD_Sound_Release(decodesound);
ERRCHECK(result);
decodesound = 0; /* This will make the read callback fail from now on. */
}
LeaveCriticalSection(&decodecrit);
/*
Shut down
*/
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
DeleteCriticalSection(&decodecrit);
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;
/*
Global Settings
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
getch();
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/drumloop.wav", FMOD_SOFTWARE, 0, &sound1);
ERRCHECK(result);
result = FMOD_Sound_SetMode(sound1, FMOD_LOOP_OFF);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/jaguar.wav", FMOD_SOFTWARE, 0, &sound2);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, 0, &channel);
ERRCHECK(result);
break;
}
case '2' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound2, 0, &channel);
ERRCHECK(result);
break;
}
case '3' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound3, 0, &channel);
ERRCHECK(result);
break;
}
}
}
FMOD_System_Update(system);
{
unsigned int ms = 0;
unsigned int lenms = 0;
int playing = 0;
int paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD_SOUND *currentsound = 0;
result = FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_Channel_GetCurrentSound(channel, ¤tsound);
if (currentsound)
{
result = FMOD_Sound_GetLength(currentsound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
result = FMOD_Sound_GetLength(sound1, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_System_GetChannelsPlaying(system, &channelsplaying);
printf("\rTime %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d", 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 = FMOD_Sound_Release(sound1);
ERRCHECK(result);
result = FMOD_Sound_Release(sound2);
ERRCHECK(result);
result = FMOD_Sound_Release(sound3);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
bool UAudioCaptureMic::init()
{
this->close();
bool ok = UAudioCapture::init();
if(ok)
{
std::string::size_type loc;
if(_fileName.size())
{
loc = _fileName.find( ".mp3", 0 );
if( loc != std::string::npos )
{
#ifdef BUILT_WITH_LAME
_encodeToMp3 = true;
#else
_fileName.append(".wav");
UERROR("Cannot write to a mp3, saving to a wav instead (%s)", _fileName.c_str());
#endif
}
_fp = fopen(_fileName.c_str(), "wb");
}
FMOD_RESULT result;
FMOD_BOOL isRecording = false;
result = UAudioSystem::isRecording(_driver, &isRecording); UASSERT_MSG(result==FMOD_OK, FMOD_ErrorString(result));
if(isRecording)
{
result = UAudioSystem::recordStop(_driver); UASSERT_MSG(result==FMOD_OK, FMOD_ErrorString(result));
}
_dataLength = 0;
_soundLength = 0;
_lastRecordPos = 0;
FMOD_CREATESOUNDEXINFO exinfo;
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = channels();
if(bytesPerSample() == 1)
{
exinfo.format = FMOD_SOUND_FORMAT_PCM8;
}
else if(bytesPerSample() == 2)
{
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
}
else if(bytesPerSample() == 3)
{
exinfo.format = FMOD_SOUND_FORMAT_PCM24;
}
else if(bytesPerSample() == 4)
{
exinfo.format = FMOD_SOUND_FORMAT_PCM32;
}
exinfo.defaultfrequency = (int)fs();
exinfo.length = exinfo.defaultfrequency * bytesPerSample() * exinfo.numchannels * 2; // 2 -> pour deux secondes
result = UAudioSystem::createSound(0, FMOD_2D | FMOD_SOFTWARE | FMOD_OPENUSER, &exinfo, &_sound); UASSERT_MSG(result==FMOD_OK, FMOD_ErrorString(result));
if(_fp)
{
int channels, bits;
float rate;
FMOD_Sound_GetFormat(_sound, 0, 0, &channels, &bits);
FMOD_Sound_GetDefaults(_sound, &rate, 0, 0, 0);
UWav::writeWavHeader(_fp, _dataLength, rate, channels, bits); // Write out the wav header. La longueur sera de 0 puisqu'elle est incunnue pour l'instant.
}
result = FMOD_Sound_GetLength(_sound, &_soundLength, FMOD_TIMEUNIT_PCM); UASSERT_MSG(result==FMOD_OK, FMOD_ErrorString(result));
}
return ok;
}
float JiwokFMODWrapper::GetBPM(const char *filename)
{
FMOD_SYSTEM *system;
FMOD_SOUND *sound;
FMOD_RESULT result;
unsigned int version;
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
//printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = FMOD_System_CreateStream(system,filename, FMOD_OPENONLY | FMOD_ACCURATETIME, 0, &sound);
// ERRCHECK(result);
unsigned int length = 0;
int channels = 0, bits = 0;
float frequency = 0;
float volume = 0, pan = 0;
int priority = 0;
FMOD_SOUND_TYPE stype;
FMOD_SOUND_FORMAT format;
result = FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_PCMBYTES);
ERRCHECK(result);
result = FMOD_Sound_GetDefaults(sound, &frequency, &volume, &pan, &priority);
ERRCHECK(result);
result = FMOD_Sound_GetFormat(sound, &stype, &format, &channels, &bits);
ERRCHECK(result);
printf("result is %d",result);
soundtouch::BPMDetect *bpm = new soundtouch::BPMDetect(channels,frequency);
//void *data;
//unsigned int read;
unsigned int bytesread;
#define CHUNKSIZE 32768 //4096
// #define CHUNKSIZE 4096
bytesread = 0;
soundtouch::SAMPLETYPE* samples = new soundtouch::SAMPLETYPE[CHUNKSIZE];
int sbytes = bits / 8;
const unsigned int NUMSAMPLES = CHUNKSIZE;
unsigned int bytes = NUMSAMPLES * sbytes;
unsigned int readbytes = 0;
do
{
readbytes = 0;
if(sbytes == 2)
{
long int data[32768];
result = FMOD_Sound_ReadData(sound, data, bytes, &readbytes );
if(!result == FMOD_OK) break;
for ( unsigned int i = 0; i < readbytes/sbytes; ++i )
samples[i] = (float) data[i] / 32768;
}
else if(sbytes == 1)
{
long int data[32768];
result = FMOD_Sound_ReadData(sound, data, bytes, &readbytes );
if(!result == FMOD_OK) break;
for ( unsigned int i = 0; i < (readbytes); ++i )
samples[i] = (float) data[i] / 128;
}
bpm->inputSamples(samples, (readbytes /sbytes)/ channels );
bytesread += readbytes;
}
while (result == FMOD_OK && readbytes == CHUNKSIZE*2);
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
float bpmg = bpm->getBpm();
float bpm1 = bpmg;
if ( bpmg < 1 ) return 0.;
while ( bpmg > 190 ) bpmg /= 2.;
while ( bpmg < 50 ) bpmg *= 2.;
printf("bpmg bpmg is %f bpm %f",bpmg,bpm1);
return bpmg;
}
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
/*
System initialization (recommended startup sequence)
*/
result = FMOD_System_GetNumDrivers(system, &numdrivers);
ERRCHECK(result);
if (numdrivers == 0)
{
result = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_NOSOUND);
ERRCHECK(result);
}
else
{
result = FMOD_System_GetDriverCaps(system, 0, &caps, 0, &speakermode);
ERRCHECK(result);
result = FMOD_System_SetSpeakerMode(system, 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 = FMOD_System_SetDSPBufferSize(system, 1024, 10);
ERRCHECK(result);
}
#ifdef LOWLATENCY
else
{
result = FMOD_System_SetDSPBufferSize(system, 256, 4);
}
#endif
result = FMOD_System_GetDriverInfo(system, 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 = FMOD_System_SetSoftwareFormat(system, 48000, FMOD_SOUND_FORMAT_PCMFLOAT, 0,0, FMOD_DSP_RESAMPLER_LINEAR);
ERRCHECK(result);
}
}
result = FMOD_System_Init(system, 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 = FMOD_System_SetSpeakerMode(system, FMOD_SPEAKERMODE_STEREO);
ERRCHECK(result);
result = FMOD_System_Init(system, 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 = FMOD_System_CreateSound(system, 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-2011.\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 = FMOD_System_RecordStart(system, 0, sound, TRUE);
ERRCHECK(result);
result = FMOD_Sound_GetLength(sound, &soundlength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
/*
Create a DSP effect to play with.
*/
result = FMOD_System_CreateDSPByType(system, FMOD_DSP_TYPE_FLANGE, &dsp);
ERRCHECK(result);
result = FMOD_DSP_SetParameter(dsp, FMOD_DSP_FLANGE_RATE, 4.0f);
ERRCHECK(result);
result = FMOD_DSP_SetBypass(dsp, 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')
{
int bypass;
FMOD_DSP_GetBypass(dsp, &bypass);
FMOD_DSP_SetBypass(dsp, !bypass);
if (bypass)
{
FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_CONCERTHALL;
FMOD_System_SetReverbProperties(system, &prop);
}
else
{
FMOD_REVERB_PROPERTIES prop = FMOD_PRESET_OFF;
FMOD_System_SetReverbProperties(system, &prop);
}
printf("\n\n *** TURN DSP EFFECT %s ** \n\n", bypass ? "ON" : "OFF");
}
FMOD_System_GetRecordPosition(system, 0, &recordpos);
ERRCHECK(result);
recorddelta = recordpos >= lastrecordpos ? recordpos - lastrecordpos : recordpos + soundlength - lastrecordpos;
samplesrecorded += recorddelta;
if (samplesrecorded >= adjustedlatency && !channel)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
result = FMOD_Channel_AddDSP(channel, 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;
}
}
FMOD_Channel_GetPosition(channel, &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 */
{
FMOD_Channel_SetFrequency(channel, 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 */
{
FMOD_Channel_SetFrequency(channel, RECORDRATE + (RECORDRATE / 50)); /* Increase speed by 2% */
adjusting = 2;
}
else
{
FMOD_Channel_SetFrequency(channel, 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;
FMOD_System_Update(system);
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
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 <volumename>\n");
printf("Example: cdplayer \"Audio CD\"\n");
exit(-1);
}
printf("==================================================================\n");
printf("CDPlayer Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("==================================================================\n\n");
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
/*
Bump up the file buffer size a bit from the 16k default for CDDA, because it is a slower medium.
*/
result = FMOD_System_SetStreamBufferSize(system, 64*1024, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
result = FMOD_System_CreateStream(system, argv[1], FMOD_OPENONLY, 0, &cdsound);
ERRCHECK(result);
result = FMOD_Sound_GetNumSubSounds(cdsound, &numtracks);
ERRCHECK(result);
result = FMOD_Sound_GetSubSound(cdsound, currenttrack, &sound);
ERRCHECK(result);
for (;;)
{
FMOD_TAG tag;
if (FMOD_Sound_GetTag(cdsound, 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 = FMOD_Sound_GetLength(cdsound, &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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, FALSE, &channel);
ERRCHECK(result);
/*
Main loop
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
int paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
break;
}
case 'n' :
{
currenttrack++;
if (currenttrack >= numtracks)
{
currenttrack = 0;
}
result = FMOD_Sound_GetSubSound(cdsound, currenttrack, &sound);
ERRCHECK(result);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, FALSE, &channel);
ERRCHECK(result);
break;
}
}
}
FMOD_System_Update(system);
if (channel)
{
unsigned int ms, lenms, percent = 0;
FMOD_BOOL playing;
FMOD_BOOL paused;
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Sound_GetLength(sound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
printf("\rTrack %d/%d : %02d:%02d:%02d/%02d:%02d:%02d : %s", 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");
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_Sound_Release(cdsound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 numtracks, currenttrack = 0;
unsigned int version;
printf("==================================================================\n");
printf("CDPlayer Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("==================================================================\n\n");
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
/*
Bump up the file buffer size a bit from the 16k default for CDDA, because it is a slower medium.
*/
result = FMOD_System_SetStreamBufferSize(system, 64*1024, FMOD_TIMEUNIT_RAWBYTES);
ERRCHECK(result);
/*
Try a few drive letters.
*/
result = FMOD_System_CreateStream(system, "d:", FMOD_OPENONLY, 0, &cdsound);
if (result != FMOD_OK)
{
result = FMOD_System_CreateStream(system, "e:", FMOD_OPENONLY, 0, &cdsound);
if (result != FMOD_OK)
{
result = FMOD_System_CreateStream(system, "f:", FMOD_OPENONLY, 0, &cdsound);
ERRCHECK(result);
}
}
result = FMOD_Sound_GetNumSubSounds(cdsound, &numtracks);
ERRCHECK(result);
for (;;)
{
FMOD_TAG tag;
if (FMOD_Sound_GetTag(cdsound, 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 = FMOD_Sound_GetLength(cdsound, &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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, cdsound, FALSE, &channel);
ERRCHECK(result);
/*
Main loop
*/
do
{
if (_kbhit())
{
key = _getch();
switch (key)
{
case ' ' :
{
int paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
break;
}
case '<' :
{
unsigned int ms;
FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_SENTENCE_MS);
if (ms >= 10000)
{
ms -= 10000;
}
else
{
ms = 0;
}
FMOD_Channel_SetPosition(channel, ms, FMOD_TIMEUNIT_SENTENCE_MS);
break;
}
case '>' :
{
unsigned int ms;
FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_SENTENCE_MS);
ms += 10000;
FMOD_Channel_SetPosition(channel, ms, FMOD_TIMEUNIT_SENTENCE_MS);
break;
}
case 'n' :
{
FMOD_Channel_GetPosition(channel, ¤ttrack, FMOD_TIMEUNIT_SENTENCE_SUBSOUND);
currenttrack++;
if (currenttrack >= numtracks)
{
currenttrack = 0;
}
FMOD_Channel_SetPosition(channel, currenttrack, FMOD_TIMEUNIT_SENTENCE_SUBSOUND);
break;
}
}
}
FMOD_System_Update(system);
if (channel)
{
unsigned int ms;
unsigned int lenms;
FMOD_BOOL playing;
FMOD_BOOL paused;
int busy;
result = FMOD_Channel_GetPaused(channel, &paused);
ERRCHECK(result);
result = FMOD_Channel_IsPlaying(channel, &playing);
ERRCHECK(result);
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_SENTENCE_MS);
ERRCHECK(result);
result = FMOD_Sound_GetLength(cdsound, &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 = FMOD_Sound_Release(cdsound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
/*
[
[DESCRIPTION]
Writes out the contents of a record buffer to a file.
[PARAMETERS]
[RETURN_VALUE]
void
[REMARKS]
]
*/
void SaveToWav(FMOD_SOUND *sound)
{
FILE *fp;
int channels, bits;
float rate;
void *ptr1, *ptr2;
unsigned int lenbytes, len1, len2;
if (!sound)
{
return;
}
FMOD_Sound_GetFormat (sound, 0, 0, &channels, &bits);
FMOD_Sound_GetDefaults(sound, &rate, 0, 0, 0);
FMOD_Sound_GetLength (sound, &lenbytes, FMOD_TIMEUNIT_PCMBYTES);
{
#if defined(WIN32) || defined(_WIN64) || defined(__WATCOMC__) || defined(_WIN32) || defined(__WIN32__)
#pragma pack(1)
#endif
/*
WAV Structures
*/
typedef struct
{
signed char id[4];
int size;
} RiffChunk;
struct
{
RiffChunk chunk __PACKED;
unsigned short wFormatTag __PACKED; /* format type */
unsigned short nChannels __PACKED; /* number of channels (i.e. mono, stereo...) */
unsigned int nSamplesPerSec __PACKED; /* sample rate */
unsigned int nAvgBytesPerSec __PACKED; /* for buffer estimation */
unsigned short nBlockAlign __PACKED; /* block size of data */
unsigned short wBitsPerSample __PACKED; /* number of bits per sample of mono data */
} __PACKED FmtChunk = { {{'f','m','t',' '}, sizeof(FmtChunk) - sizeof(RiffChunk) }, 1, channels, (int)rate, (int)rate * channels * bits / 8, 1 * channels * bits / 8, bits };
struct
{
RiffChunk chunk;
} DataChunk = { {{'d','a','t','a'}, lenbytes } };
struct
{
RiffChunk chunk;
signed char rifftype[4];
} WavHeader = { {{'R','I','F','F'}, sizeof(FmtChunk) + sizeof(RiffChunk) + lenbytes }, {'W','A','V','E'} };
#if defined(WIN32) || defined(_WIN64) || defined(__WATCOMC__) || defined(_WIN32) || defined(__WIN32__)
#pragma pack()
#endif
fp = fopen("record.wav", "wb");
/*
Write out the WAV header.
*/
fwrite(&WavHeader, sizeof(WavHeader), 1, fp);
fwrite(&FmtChunk, sizeof(FmtChunk), 1, fp);
fwrite(&DataChunk, sizeof(DataChunk), 1, fp);
/*
Lock the sound to get access to the raw data.
*/
FMOD_Sound_Lock(sound, 0, lenbytes, &ptr1, &ptr2, &len1, &len2);
/*
Write it to disk.
*/
fwrite(ptr1, len1, 1, fp);
/*
Unlock the sound to allow FMOD to use it again.
*/
FMOD_Sound_Unlock(sound, ptr1, ptr2, len1, len2);
fclose(fp);
}
}
int main(int argc, char *argv[])
{
int att = 1, motion_state = 0, status = STOP;
float volume;
SDL_Event event;
SDL_Surface *ecran = NULL, *fond = NULL, *play = NULL, *stop = NULL, *pause = NULL, *volumeup = NULL, *volumedown = NULL, *spectrum = NULL;
SDL_Surface *iplay = NULL, *ipause = NULL, *istop = NULL, *ivolup = NULL, *ivoldo = NULL;
SDL_Rect pos_fond, pos_spect, pos_play, pos_pause, pos_stop, pos_volumeup, pos_volumedown;
printf("Démarrage de Freqalyzer\n");
FMOD_SYSTEM *system;
FMOD_SOUND *sound;
FMOD_CHANNEL *channel=0;
FMOD_RESULT result;
FMOD_BOOL state;
void *extradriverdata = 0;
pos_fond.x = 0;
pos_fond.y = 0;
pos_spect.x = 100;
pos_spect.y = 150;
pos_play.x = 100;
pos_play.y = 520;
pos_pause.x = 100 + CONTROLLER_SIZE;
pos_pause.y = 520;
pos_stop.x = 100 + (CONTROLLER_SIZE * 2);
pos_stop.y = 520;
pos_volumeup.x = 100 + (CONTROLLER_SIZE * 3);
pos_volumeup.y = 520;
pos_volumedown.x = 100 + (CONTROLLER_SIZE * 4);
pos_volumedown.y = 520;
//Chargement en mémoire du système d'affichage SDL - Vidéo
SDL_Init(SDL_INIT_VIDEO);
if(SDL_Init(SDL_INIT_VIDEO) == -1)
{
fprintf(stderr, "Erreur d'initialisation de la SDL");
exit(EXIT_FAILURE);
}
//Paramétrage et ouverture de la fenêtre
ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);
spectrum = SDL_CreateRGBSurface(SDL_HWSURFACE, 600, 350, 32, 0, 0, 0, 0);
SDL_FillRect(spectrum, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
//Titrage de la fenêtre
SDL_WM_SetCaption("Freqalyzer", NULL);
//Chargement des images
fond = IMG_Load("../pictures/fond.jpg");
W_GestionErreur(P_IMAGE, 0, fond, "fond.jpg");
play = IMG_Load("../pictures/play.jpg");
W_GestionErreur(P_IMAGE, 0, play, "play.jpg");
pause = IMG_Load("../pictures/pause.jpg");
W_GestionErreur(P_IMAGE, 0, pause, "pause.jpg");
stop = IMG_Load("../pictures/stop.jpg");
W_GestionErreur(P_IMAGE, 0, stop, "stop.jpg");
volumeup = IMG_Load("../pictures/volume_up.jpg");
W_GestionErreur(P_IMAGE, 0, volumeup, "volume_up.jpg");
volumedown = IMG_Load("../pictures/volume_down.jpg");
W_GestionErreur(P_IMAGE, 0, volumedown, "volume_down.jpg");
iplay = IMG_Load("../pictures/iplay.jpg");
W_GestionErreur(P_IMAGE, 0, iplay, "iplay.jpg");
ipause = IMG_Load("../pictures/ipause.jpg");
W_GestionErreur(P_IMAGE, 0, ipause, "ipause.jpg");
istop = IMG_Load("../pictures/istop.jpg");
W_GestionErreur(P_IMAGE, 0, istop, "istop.jpg");
ivolup = IMG_Load("../pictures/ivolume_up.jpg");
W_GestionErreur(P_IMAGE, 0, ivolup, "ivolume_up.jpg");
ivoldo = IMG_Load("../pictures/ivolume_down.jpg");
W_GestionErreur(P_IMAGE, 0, ivoldo, "ivolume_down.jpg");
//Allocation de mémoire à system
result = FMOD_System_Create(&system);
W_GestionErreur(P_CREASON, result, NULL, "");
//Initialisation
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, extradriverdata);
W_GestionErreur(P_CHARGSON, result, NULL, "");
result = FMOD_System_CreateSound(system, "../sounds/radio_sig.mp3", FMOD_2D | FMOD_CREATESTREAM, 0, &sound);
/* //Chargement du son
result = FMOD_System_CreateSound(system, argv[1], FMOD_2D | FMOD_CREATESTREAM, 0, &sound);
if (result != 0)
{
printf("\nErreur de saisie, veuillez taper un chemin correct \n(ex : ./Freqalyser ../sounds/gameofthrones.mp3)\n");
exit(EXIT_FAILURE);
}*/
while(att)
{
SDL_WaitEvent(&event);
if (event.motion.x > 100 && event.motion.x < (100 + CONTROLLER_SIZE * 5) && event.motion.y > 520 && event.motion.y < (520 + CONTROLLER_SIZE))
{
motion_state = 1;
W_event(ecran, iplay, ipause, istop, ivolup, ivoldo);
}else
motion_state = 0;
switch(event.type)
{
case SDL_QUIT:
att = 0;
break;
case SDL_MOUSEBUTTONUP:
if (event.button.x > 100 && event.button.x < (100 + CONTROLLER_SIZE) && event.button.y > 520 && event.button.y < (520 + CONTROLLER_SIZE))
{
//jouer le son et mettre en pause le programme le temps de sa lecture
result=FMOD_System_PlaySound(system, sound, 0, 0, &channel);
W_GestionErreur(P_LECTURE, result, NULL, "");
unsigned int length;
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_MS);
FMOD_Channel_GetVolume(channel, &volume);
FMOD_Channel_GetVolume(channel, &volume);
status = PLAY;
}
if (event.button.x > (100 + CONTROLLER_SIZE) && event.button.x < (100 + (CONTROLLER_SIZE * 2)) && event.button.y > 520 && event.button.y < (520 + CONTROLLER_SIZE))
{
FMOD_System_GetChannel(system, 512, &channel);
FMOD_Channel_GetPaused(channel, &state);
if(state)
{
FMOD_Channel_SetPaused(channel, 0);
status = PLAY;
}
else
{
FMOD_Channel_SetPaused(channel, 1);
status = PAUSE;
}
}
if (event.button.x > (100 + CONTROLLER_SIZE * 2) && event.button.x < (100 + CONTROLLER_SIZE * 3) && event.button.y > 520 && event.button.y < (520 + CONTROLLER_SIZE))
{
FMOD_Channel_Stop(channel);
status = STOP;
}
if (event.button.x > (100 + CONTROLLER_SIZE * 3) && event.button.x < (100 + CONTROLLER_SIZE * 4) && event.button.y > 520 && event.button.y < (520 + CONTROLLER_SIZE))
result = W_GestionVolume(&volume, channel, UP);
if (event.button.x > (100 + CONTROLLER_SIZE * 4) && event.button.x < (100 + CONTROLLER_SIZE * 5) && event.button.y > 520 && event.button.y < (520 + CONTROLLER_SIZE))
result = W_GestionVolume(&volume, channel, DOWN);
break;
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_ESCAPE:
att = 0;
break;
case SDLK_SPACE:
//jouer le son et mettre en pause le programme le temps de sa lecture
result=FMOD_System_PlaySound(system, sound, 0, 0, &channel);
unsigned int length;
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_MS);
FMOD_Channel_GetVolume(channel, &volume);
FMOD_Channel_GetVolume(channel, &volume);
status = PLAY;
break;
case SDLK_UP:
result = W_GestionVolume(&volume, channel, UP);
break;
case SDLK_DOWN:
result = W_GestionVolume(&volume, channel, DOWN);
break;
case SDLK_p:
FMOD_System_GetChannel(system, 512, &channel);
FMOD_Channel_GetPaused(channel, &state);
if(state)
{
FMOD_Channel_SetPaused(channel, 0);
status = PLAY;
}
else
{
FMOD_Channel_SetPaused(channel, 1);
status = PAUSE;
}
break;
case SDLK_s:
FMOD_Channel_Stop(channel);
status = STOP;
break;
default:
break;
}
default:
break;
}
//Affichage des surfaces
SDL_BlitSurface(fond, NULL, ecran, &pos_fond);
SDL_BlitSurface(spectrum, NULL, ecran, &pos_spect);
switch (status)
{
case PLAY:
SDL_BlitSurface(iplay, NULL, ecran, &pos_play);
SDL_BlitSurface(pause, NULL, ecran, &pos_pause);
SDL_BlitSurface(stop, NULL, ecran, &pos_stop);
break;
case PAUSE:
SDL_BlitSurface(play, NULL, ecran, &pos_play);
SDL_BlitSurface(ipause, NULL, ecran, &pos_pause);
SDL_BlitSurface(stop, NULL, ecran, &pos_stop);
break;
case STOP:
SDL_BlitSurface(play, NULL, ecran, &pos_play);
SDL_BlitSurface(pause, NULL, ecran, &pos_pause);
SDL_BlitSurface(istop, NULL, ecran, &pos_stop);
break;
default:
break;
}
SDL_BlitSurface(volumeup, NULL, ecran, &pos_volumeup);
SDL_BlitSurface(volumedown, NULL, ecran, &pos_volumedown);
//Rafraîchissement de la fenêtre
SDL_Flip(ecran);
FMOD_System_Update(system);
}
//Fermeture et libération de l'objet system en mémoire
FMOD_Sound_Release(sound);
FMOD_System_Close(system);
FMOD_System_Release(system);
SDL_FreeSurface(spectrum);
SDL_FreeSurface(fond);
SDL_FreeSurface(play);
SDL_FreeSurface(pause);
SDL_FreeSurface(stop);
SDL_FreeSurface(volumeup);
SDL_FreeSurface(volumedown);
SDL_FreeSurface(iplay);
SDL_FreeSurface(ipause);
SDL_FreeSurface(istop);
SDL_FreeSurface(ivolup);
SDL_FreeSurface(ivoldo);
SDL_Quit();
return EXIT_SUCCESS;
}
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_LOOP_NORMAL | FMOD_HARDWARE;
int key;
int channels = 2;
FMOD_CREATESOUNDEXINFO createsoundexinfo;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
printf("============================================================================\n");
printf("User Created Sound Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("============================================================================\n");
printf("Sound played here is generated in realtime. It will either play as a stream\n");
printf("which means it is continually filled as it is playing, or it will play as a \n");
printf("static sample, which means it is filled once as the sound is created, then \n");
printf("when played it will just play that short loop of data. \n");
printf("============================================================================\n");
printf("\n");
do
{
printf("Press 1 to play as a runtime decoded stream. (will carry on infinitely)\n");
printf("Press 2 to play as a static in memory sample. (loops a short block of data)\n");
printf("Press Esc to quit.\n\n");
key = getch();
} while (key != 27 && key != '1' && key != '2');
if (key == 27)
{
return 0;
}
else if (key == '1')
{
mode |= FMOD_CREATESTREAM;
}
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.length = 44100 * channels * sizeof(signed short) * 5; /* Length of PCM data in bytes of whole song (for Sound::getLength) */
createsoundexinfo.numchannels = channels; /* Number of channels in the sound. */
createsoundexinfo.defaultfrequency = 44100; /* 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 = FMOD_System_CreateSound(system, 0, mode, &createsoundexinfo, &sound);
ERRCHECK(result);
printf("Press space to pause, Esc to quit\n");
printf("\n");
/*
Play the sound.
*/
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
int paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
break;
}
}
}
FMOD_System_Update(system);
if (channel)
{
unsigned int ms;
unsigned int lenms;
int playing;
int paused;
FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Sound_GetLength(sound, &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");
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD_SYSTEM *system = 0;
FMOD_SOUND *playlist = 0;
FMOD_SOUND *sound = 0;
FMOD_CHANNEL *channel = 0;
FMOD_TAG tag;
FMOD_RESULT result;
FMOD_SOUND_TYPE soundtype;
FMOD_BOOL isplaylist = 0;
char *title = NULL;
int count = 0;
int key;
unsigned int version;
char file[128];
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/playlist.m3u", FMOD_DEFAULT, 0, &playlist);
ERRCHECK(result);
result = FMOD_Sound_GetFormat(playlist, &soundtype, 0, 0, 0);
ERRCHECK(result);
isplaylist = (soundtype == FMOD_SOUND_TYPE_PLAYLIST);
printf("===================================================================\n");
printf("PlayList Example. Copyright (c) Firelight Technologies 2004-2015.\n");
printf("===================================================================\n");
printf("\n");
printf("Press 'n' to play next sound in playlist\n");
printf("Press 'space' to pause/unpause current sound\n");
printf("Press 'Esc' to quit\n");
printf("\n");
if (isplaylist)
{
printf("PLAYLIST loaded.\n");
/*
Get the first song in the playlist, create the sound and then play it.
*/
result = FMOD_Sound_GetTag(playlist, "FILE", count, &tag);
ERRCHECK(result);
sprintf(file, "../media/%s", (char *)tag.data);
result = FMOD_System_CreateSound(system, file, FMOD_DEFAULT, 0, &sound);
ERRCHECK(result);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
FMOD_Sound_GetTag(playlist, "TITLE", count, &tag);
title = (char *)tag.data;
count++;
}
else
{
printf("SOUND loaded.\n");
/*
This is just a normal sound, so just play it.
*/
sound = playlist;
result = FMOD_Sound_SetMode(sound, FMOD_LOOP_NORMAL);
ERRCHECK(result);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
}
printf("\n");
/*
Main loop.
*/
do
{
FMOD_BOOL isplaying = 0;
if (channel && isplaylist)
{
/*
When sound has finished playing, play the next sound in the playlist
*/
FMOD_Channel_IsPlaying(channel, &isplaying);
if (!isplaying)
{
if (sound)
{
FMOD_Sound_Release(sound);
sound = NULL;
}
result = FMOD_Sound_GetTag(playlist, "FILE", count, &tag);
if (result != FMOD_OK)
{
count = 0;
}
else
{
printf("playing next song in playlist...\n");
sprintf(file, "../media/%s", (char *)tag.data);
result = FMOD_System_CreateSound(system, file, FMOD_DEFAULT, 0, &sound);
ERRCHECK(result);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
FMOD_Sound_GetTag(playlist, "TITLE", count, &tag);
title = (char *)tag.data;
count++;
}
}
}
if (_kbhit())
{
key = _getch();
switch (key)
{
case 'n' :
{
/*
Play the next song in the playlist
*/
if (channel && isplaylist)
{
FMOD_Channel_Stop(channel);
}
break;
}
case ' ' :
{
if (channel)
{
FMOD_BOOL paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
}
}
}
}
FMOD_System_Update(system);
{
unsigned int ms = 0;
unsigned int lenms = 0;
FMOD_BOOL paused = 0;
if (channel)
{
if (sound)
{
result = FMOD_Sound_GetLength(sound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, 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 : %s\r", ms / 1000 / 60, ms / 1000 % 60, ms / 10 % 100, lenms / 1000 / 60, lenms / 1000 % 60, lenms / 10 % 100, paused ? "Paused " : "Playing ", title);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
if (sound)
{
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
}
if (isplaylist)
{
result = FMOD_Sound_Release(playlist);
ERRCHECK(result);
}
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
/*
[
[DESCRIPTION]
Writes out the contents of a record buffer to a file.
[PARAMETERS]
[RETURN_VALUE]
void
[REMARKS]
]
*/
void SaveToWav(FMOD_SOUND *sound)
{
FILE *fp;
int channels, bits;
float rate;
void *ptr1, *ptr2;
unsigned int lenbytes, len1, len2;
FMOD_SOUND_FORMAT format;
int count = 0;
if (!sound)
{
return;
}
FMOD_Sound_GetFormat (sound, 0, &format, &channels, &bits);
FMOD_Sound_GetDefaults(sound, &rate, 0, 0, 0);
FMOD_Sound_GetLength (sound, &lenbytes, FMOD_TIMEUNIT_PCMBYTES);
{
/*
WAV Structures
*/
typedef struct
{
signed char id[4];
int size;
} RiffChunk;
struct
{
RiffChunk chunk __PACKED;
unsigned short wFormatTag __PACKED; /* format type */
unsigned short nChannels __PACKED; /* number of channels (i.e. mono, stereo...) */
unsigned int nSamplesPerSec __PACKED; /* sample rate */
unsigned int nAvgBytesPerSec __PACKED; /* for buffer estimation */
unsigned short nBlockAlign __PACKED; /* block size of data */
unsigned short wBitsPerSample __PACKED; /* number of bits per sample of mono data */
} __PACKED FmtChunk = { {{'f','m','t',' '}, sizeof(FmtChunk) - sizeof(RiffChunk) }, 1, channels, (int)rate, (int)rate * channels * bits / 8, 1 * channels * bits / 8, bits };
if (format == FMOD_SOUND_FORMAT_PCMFLOAT)
{
FmtChunk.wFormatTag = 3;
}
struct
{
RiffChunk chunk;
} DataChunk = { {{'d','a','t','a'}, lenbytes } };
struct
{
RiffChunk chunk;
signed char rifftype[4];
} WavHeader = { {{'R','I','F','F'}, sizeof(FmtChunk) + sizeof(RiffChunk) + lenbytes }, {'W','A','V','E'} };
#ifdef __BIG_ENDIAN__
/*
Do some endian swapping
*/
FmtChunk.chunk.size = SWAPENDIAN_DWORD(FmtChunk.chunk.size);
FmtChunk.wFormatTag = SWAPENDIAN_WORD(FmtChunk.wFormatTag);
FmtChunk.nChannels = SWAPENDIAN_WORD(FmtChunk.nChannels);
FmtChunk.nSamplesPerSec = SWAPENDIAN_DWORD(FmtChunk.nSamplesPerSec);
FmtChunk.nAvgBytesPerSec = SWAPENDIAN_DWORD(FmtChunk.nAvgBytesPerSec);
FmtChunk.nBlockAlign = SWAPENDIAN_WORD(FmtChunk.nBlockAlign);
FmtChunk.wBitsPerSample = SWAPENDIAN_WORD(FmtChunk.wBitsPerSample);
DataChunk.chunk.size = SWAPENDIAN_DWORD(DataChunk.chunk.size);
WavHeader.chunk.size = SWAPENDIAN_DWORD(WavHeader.chunk.size);
#endif
fp = fopen("record.wav", "wb");
/*
Write out the WAV header.
*/
fwrite(&WavHeader, sizeof(WavHeader), 1, fp);
fwrite(&FmtChunk, sizeof(FmtChunk), 1, fp);
fwrite(&DataChunk, sizeof(DataChunk), 1, fp);
/*
Lock the sound to get access to the raw data.
*/
FMOD_Sound_Lock(sound, 0, lenbytes, &ptr1, &ptr2, &len1, &len2);
#ifdef __BIG_ENDIAN__
/*
Write it to disk.
*/
if (format == FMOD_SOUND_FORMAT_PCM16)
{
signed short *wptr = (signed short *)ptr1;
for (count = 0; count < len1 >> 1; count++)
{
wptr[count] = SWAPENDIAN_WORD(wptr[count]);
}
}
else if (format == FMOD_SOUND_FORMAT_PCMFLOAT)
{
float *fptr = (float *)ptr1;
for (count = 0; count < len1 >> 2; count++)
{
SWAPENDIAN_FLOAT(fptr[count]);
}
}
#endif
fwrite(ptr1, len1, 1, fp);
/*
Unlock the sound to allow FMOD to use it again.
*/
FMOD_Sound_Unlock(sound, ptr1, ptr2, len1, len2);
fclose(fp);
}
}
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
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 = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_OSS);
break;
case '2' :
result = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_ALSA);
break;
case '3' :
result = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_ESD);
break;
default :
return 1;
}
ERRCHECK(result);
/*
Enumerate playback devices
*/
result = FMOD_System_GetNumDrivers(system, &numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a PLAYBACK driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = FMOD_System_GetDriverInfo(system, 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 = FMOD_System_SetDriver(system, driver);
ERRCHECK(result);
/*
Enumerate record devices
*/
result = FMOD_System_GetRecordNumDrivers(system, &numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = FMOD_System_GetRecordDriverInfo(system, 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 = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
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 = FMOD_System_CreateSound(system, 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 int looping = 0;
int recording = 0;
int playing = 0;
unsigned int recordpos = 0;
unsigned int playpos = 0;
unsigned int length;
if (kbhit())
{
key = getch();
switch (key)
{
case 'r' :
case 'R' :
{
result = FMOD_System_RecordStart(system, recorddriver, sound, looping);
ERRCHECK(result);
break;
}
case 'p' :
case 'P' :
{
if (looping)
{
FMOD_Sound_SetMode(sound, FMOD_LOOP_NORMAL);
}
else
{
FMOD_Sound_SetMode(sound, FMOD_LOOP_OFF);
}
ERRCHECK(result);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_REUSE, sound, 0, &channel);
ERRCHECK(result);
break;
}
case 'l' :
case 'L' :
{
looping = !looping;
break;
}
case 's' :
case 'S' :
{
result = FMOD_System_RecordStop(system, recorddriver);
if (channel)
{
FMOD_Channel_Stop(channel);
channel = 0;
}
break;
}
case 'w' :
case 'W' :
{
printf("Writing to record.wav ... \r");
SaveToWav(sound);
Sleep(500);
break;
}
}
}
FMOD_Sound_GetLength(sound, &length, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
FMOD_System_IsRecording(system, recorddriver, &recording);
ERRCHECK(result);
FMOD_System_GetRecordPosition(system, recorddriver, &recordpos);
ERRCHECK(result);
if (channel)
{
FMOD_Channel_IsPlaying(channel, &playing);
ERRCHECK(result);
FMOD_Channel_GetPosition(channel, &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);
FMOD_System_Update(system);
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 = FMOD_System_CreateStream(gSystem, soundname[newindex], FMOD_IGNORETAGS | FMOD_LOWMEM, &info, &sound[slot]);
ERRCHECK(result);
newsound = sound[slot];
#else /* Use an existing sound that was passed into us */
newsound = sound[newindex];
#endif
result = FMOD_System_PlaySound(gSystem, FMOD_CHANNEL_FREE, newsound, 1, &newchannel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(newchannel, 1,1,1,1,1,1,1,1);
ERRCHECK(result);
if (playingchannel)
{
unsigned int hi = 0, lo = 0, sound_length;
float sound_frequency;
FMOD_SOUND *playingsound;
/*
Get the start time of the playing channel.
*/
result = FMOD_Channel_GetDelay(playingchannel, FMOD_DELAYTYPE_DSPCLOCK_START, &hi, &lo);
ERRCHECK(result);
printf("playing sound started at %d\n", lo);
/*
Grab the length of the playing sound, and its frequency, so we can caluate where to place the new sound on the time line.
*/
result = FMOD_Channel_GetCurrentSound(playingchannel, &playingsound);
ERRCHECK(result);
result = FMOD_Sound_GetLength(playingsound, &sound_length, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
result = FMOD_Channel_GetFrequency(playingchannel, &sound_frequency);
ERRCHECK(result);
/*
Now calculate the length of the sound in 'output samples'.
Ie if a 44khz sound is 22050 samples long, and the output rate is 48khz, then we want to delay by 24000 output samples.
*/
sound_length *= outputrate;
sound_length /= (int)sound_frequency;
FMOD_64BIT_ADD(hi, lo, 0, sound_length); /* Add output rate adjusted sound length, to the clock value of the sound that is currently playing */
result = FMOD_Channel_SetDelay(newchannel, FMOD_DELAYTYPE_DSPCLOCK_START, hi, lo); /* Set the delay of the new sound to the end of the old sound */
ERRCHECK(result);
}
{
unsigned int hi = 0, lo = 0;
float val, variation;
/*
Randomize pitch/volume to make it sound more realistic / random.
*/
FMOD_Channel_GetFrequency(newchannel, &val);
variation = (((float)(rand()%10000) / 5000.0f) - 1.0f); /* -1.0 to +1.0 */
val *= (1.0f + (variation * 0.02f)); /* @22khz, range fluctuates from 21509 to 22491 */
FMOD_Channel_SetFrequency(newchannel, val);
FMOD_Channel_GetVolume(newchannel, &val);
variation = ((float)(rand()%10000) / 10000.0f); /* 0.0 to 1.0 */
val *= (1.0f - (variation * 0.2f)); /* 0.8 to 1.0 */
FMOD_Channel_SetVolume(newchannel, val);
FMOD_Channel_GetDelay(newchannel, FMOD_DELAYTYPE_DSPCLOCK_START, &hi, &lo);
printf("new sound to start at %d (slot %d)\n", lo, slot);
}
result = FMOD_Channel_SetPaused(newchannel, FALSE);
ERRCHECK(result);
return newchannel;
}
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = FMOD_System_CreateStream(system, "../media/wave.mp3", FMOD_OPENONLY | FMOD_ACCURATETIME, 0, &sound);
ERRCHECK(result);
printf("===============================================================================\n");
printf("Offline Decoding Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("===============================================================================\n");
printf("\n");
printf("This program will open wave.mp3 and decode it into wave.raw using the\n");
printf("FMOD_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 = FMOD_Sound_GetLength(sound, &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 = FMOD_Sound_ReadData(sound, (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 = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}
int main(int argc, char *argv[])
{
FMOD_SYSTEM *system;
FMOD_SOUND *sound;
FMOD_CHANNEL *channel = 0;
FMOD_RESULT result;
int key;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD_System_Create(&system);
ERRCHECK(result);
result = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 1, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
result = FMOD_System_SetFileSystem(system, myopen, myclose, myread, myseek, 0, 0, 2048);
ERRCHECK(result);
result = FMOD_System_CreateStream(system, "../media/wave.mp3", FMOD_HARDWARE | FMOD_LOOP_NORMAL | FMOD_2D, 0, &sound);
ERRCHECK(result);
printf("====================================================================\n");
printf("PlayStream Example. Copyright (c) Firelight Technologies 2004-2011.\n");
printf("====================================================================\n");
printf("\n");
printf("Press space to pause, Esc to quit\n");
printf("\n");
/*
Play the sound.
*/
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound, 0, &channel);
ERRCHECK(result);
/*
Main loop.
*/
do
{
if (kbhit())
{
key = getch();
switch (key)
{
case ' ' :
{
int paused;
FMOD_Channel_GetPaused(channel, &paused);
FMOD_Channel_SetPaused(channel, !paused);
break;
}
}
}
FMOD_System_Update(system);
if (channel)
{
unsigned int ms;
unsigned int lenms;
int playing;
int paused;
FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Sound_GetLength(sound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
printf("\rTime %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");
fflush(stdout);
}
Sleep(10);
} while (key != 27);
printf("\n");
/*
Shut down
*/
result = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
/*
Choose the speaker mode selected by the Windows control panel.
*/
result = FMOD_System_GetDriverCaps(system, 0, 0, 0, &speakermode);
ERRCHECK(result);
result = FMOD_System_SetSpeakerMode(system, speakermode);
ERRCHECK(result);
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/drumloop.wav", FMOD_SOFTWARE | FMOD_2D, 0, &sound1);
ERRCHECK(result);
result = FMOD_Sound_SetMode(sound1, FMOD_LOOP_OFF);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/stereo.ogg", FMOD_SOFTWARE | FMOD_2D, 0, &sound2);
ERRCHECK(result);
printf("==============================================================================\n");
printf("Multi Speaker Output Example. Copyright (c) Firelight Technologies 2004-2011.\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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 1.0f, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
break;
}
case '2' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 1.0f, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
break;
}
case '3' :
{
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 1.0f, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
case '4' :
{
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 0, 0, 1.0f, 0, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
case '5' :
{
if (speakermode >= FMOD_SPEAKERMODE_QUAD)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 0, 0, 0, 1.0f, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
case '6' :
{
if (speakermode >= FMOD_SPEAKERMODE_7POINT1)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 0, 0, 0, 0, 1.0f, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
case '7' :
{
if (speakermode >= FMOD_SPEAKERMODE_7POINT1)
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, TRUE, &channel);
ERRCHECK(result);
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 0, 0, 0, 0, 0, 1.0f);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
case '8' :
{
float levels[2] = { 0, 1.0f };
result = FMOD_System_PlaySound(system, 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 = FMOD_Channel_SetSpeakerMix(channel, 1.0f, 1.0f, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
break;
}
case '9' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound2, TRUE, &channel);
ERRCHECK(result);
/*
Clear out all speakers first.
*/
result = FMOD_Channel_SetSpeakerMix(channel, 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 = FMOD_Channel_SetSpeakerLevels(channel, 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 = FMOD_Channel_SetSpeakerLevels(channel, FMOD_SPEAKER_FRONT_RIGHT, levels, 2);
ERRCHECK(result);
}
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
break;
}
case '0' :
{
if (speakermode >= FMOD_SPEAKERMODE_SURROUND) /* All formats that have a center speaker. */
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound2, TRUE, &channel);
ERRCHECK(result);
/*
Clear out all speakers first.
*/
result = FMOD_Channel_SetSpeakerMix(channel, 0, 0, 0, 0, 0, 0, 0, 0);
ERRCHECK(result);
/*
Put the right channel of the sound in the center speaker.
*/
{
float levels[2] = { 0, 1.0f }; /* This array represents the source stereo sound. l/r */
result = FMOD_Channel_SetSpeakerLevels(channel, FMOD_SPEAKER_FRONT_CENTER, levels, 2);
ERRCHECK(result);
}
result = FMOD_Channel_SetPaused(channel, FALSE);
ERRCHECK(result);
}
break;
}
}
}
FMOD_System_Update(system);
{
unsigned int ms = 0;
unsigned int lenms = 0;
int playing = FALSE;
int paused = FALSE;
int channelsplaying = 0;
if (channel)
{
FMOD_SOUND *currentsound = 0;
result = FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_Channel_GetCurrentSound(channel, ¤tsound);
if (currentsound)
{
result = FMOD_Sound_GetLength(currentsound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
FMOD_System_GetChannelsPlaying(system, &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 = FMOD_Sound_Release(sound1);
ERRCHECK(result);
result = FMOD_Sound_Release(sound2);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, NULL);
ERRCHECK(result);
LoadFileIntoMemory("../media/drumloop.wav", &buff, &length);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = length;
result = FMOD_System_CreateSound(system, (const char *)buff, FMOD_HARDWARE | FMOD_OPENMEMORY, &exinfo, &sound1);
ERRCHECK(result);
result = FMOD_Sound_SetMode(sound1, 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 = FMOD_System_CreateSound(system, (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 = FMOD_System_CreateSound(system, (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 = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound1, 0, &channel);
ERRCHECK(result);
break;
}
case '2' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound2, 0, &channel);
ERRCHECK(result);
break;
}
case '3' :
{
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, sound3, 0, &channel);
ERRCHECK(result);
break;
}
}
}
FMOD_System_Update(system);
{
unsigned int ms = 0;
unsigned int lenms = 0;
int playing = 0;
int paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD_SOUND *currentsound = 0;
result = FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_Channel_GetCurrentSound(channel, ¤tsound);
if (currentsound)
{
result = FMOD_Sound_GetLength(currentsound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
result = FMOD_Sound_GetLength(sound1, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_System_GetChannelsPlaying(system, &channelsplaying);
printf("\rTime %02d:%02d:%02d/%02d:%02d:%02d : %s : Channels Playing %2d", 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 = FMOD_Sound_Release(sound1);
ERRCHECK(result);
result = FMOD_Sound_Release(sound2);
ERRCHECK(result);
result = FMOD_Sound_Release(sound3);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
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 = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_DSOUND);
break;
case '2' : result = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_WINMM);
break;
case '3' : result = FMOD_System_SetOutput(system, FMOD_OUTPUTTYPE_ASIO);
break;
default : return 1;
}
ERRCHECK(result);
/*
Enumerate record devices
*/
result = FMOD_System_GetRecordNumDrivers(system, &numdrivers);
ERRCHECK(result);
printf("---------------------------------------------------------\n");
printf("Choose a RECORD driver\n");
printf("---------------------------------------------------------\n");
for (count=0; count < numdrivers; count++)
{
char name[256];
result = FMOD_System_GetRecordDriverInfo(system, 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 = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
memset(&exinfo, 0, sizeof(FMOD_CREATESOUNDEXINFO));
exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.numchannels = 2;
exinfo.format = FMOD_SOUND_FORMAT_PCM16;
exinfo.defaultfrequency = 44100;
exinfo.length = exinfo.defaultfrequency * sizeof(short) * exinfo.numchannels * 2;
result = FMOD_System_CreateSound(system, 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 = FMOD_System_RecordStart(system, 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 = FMOD_Sound_GetLength(sound, &soundlength, FMOD_TIMEUNIT_PCM);
ERRCHECK(result);
/*
Main loop.
*/
do
{
static unsigned int lastrecordpos = 0;
unsigned int recordpos = 0;
if (_kbhit())
{
key = _getch();
}
FMOD_System_GetRecordPosition(system, 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.
*/
FMOD_Sound_Lock(sound, 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.
*/
FMOD_Sound_Unlock(sound, 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);
FMOD_System_Update(system);
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 = FMOD_Sound_Release(sound);
ERRCHECK(result);
result = FMOD_System_Release(system);
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 = FMOD_System_GetVersion(system, &version);
ERRCHECK(result);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return 0;
}
result = FMOD_System_Init(system, 32, FMOD_INIT_NORMAL, 0);
ERRCHECK(result);
result = FMOD_System_CreateSound(system, "../media/example.fsb", FMOD_DEFAULT, 0, &fsb);
ERRCHECK(result);
printf("===================================================================\n");
printf("FSB Example. Copyright (c) Firelight Technologies 2004-2014.\n");
printf("===================================================================\n");
printf("\n");
result = FMOD_Sound_GetNumSubSounds(fsb, &numsubsounds);
ERRCHECK(result);
for (count = 0; count < numsubsounds; count++)
{
FMOD_SOUND *subsound;
char name[256];
result = FMOD_Sound_GetSubSound(fsb, count, &subsound);
ERRCHECK(result);
result = FMOD_Sound_GetName(subsound, 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';
FMOD_Sound_GetSubSound(fsb, index, &subsound);
result = FMOD_System_PlaySound(system, FMOD_CHANNEL_FREE, subsound, FALSE, &channel);
ERRCHECK(result);
}
}
FMOD_System_Update(system);
{
unsigned int ms = 0;
unsigned int lenms = 0;
int playing = 0;
int paused = 0;
int channelsplaying = 0;
if (channel)
{
FMOD_SOUND *currentsound = 0;
result = FMOD_Channel_IsPlaying(channel, &playing);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPaused(channel, &paused);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
result = FMOD_Channel_GetPosition(channel, &ms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
FMOD_Channel_GetCurrentSound(channel, ¤tsound);
if (currentsound)
{
result = FMOD_Sound_GetLength(currentsound, &lenms, FMOD_TIMEUNIT_MS);
if ((result != FMOD_OK) && (result != FMOD_ERR_INVALID_HANDLE) && (result != FMOD_ERR_CHANNEL_STOLEN))
{
ERRCHECK(result);
}
}
}
FMOD_System_GetChannelsPlaying(system, &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 = FMOD_Sound_Release(fsb);
ERRCHECK(result);
result = FMOD_System_Close(system);
ERRCHECK(result);
result = FMOD_System_Release(system);
ERRCHECK(result);
return 0;
}