void SOUND_play_song(int idx)
{
g_MusicIndex = idx ;
mod = FMUSIC_LoadSong("", NULL);
FMUSIC_PlaySong(mod);
}
// 20110501/supah: replaced this for non-console windowed version :)
//int main(int argc, char* argv[]) {
int PASCAL WinMain(HINSTANCE hi, HINSTANCE pi, LPSTR cmd, int show) {
Window window(RESX, RESY, BPP, TITLE, FULLSCREEN);
GLContext glc(window);
EffectPlayer effectPlayer;
glc.setDefaultParameters();
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
FMUSIC_MODULE* mod = FMUSIC_LoadSong("", 0);
FMUSIC_PlaySong(mod);
float startTime = (float) FMUSIC_GetTime(mod); // timeGetTime();
while(window.active() && effectPlayer.isRunning()) {
//float time = (float)timeGetTime() - startTime;
float time = FMUSIC_GetTime(mod) - startTime;
effectPlayer.run(time);
glc.flush();
}
FMUSIC_StopSong(mod);
return 0;
}
int main()
{
FMUSIC_MODULE *mod = NULL;
if (FSOUND_GetVersion() < FMOD_VERSION)
{
printf("Error : You are using the wrong DLL version! You should be using FMOD %.02f\n", FMOD_VERSION);
exit(1);
}
/*
INITIALIZE
*/
if (!FSOUND_Init(32000, 64, 0))
{
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
exit(1);
}
/*
LOAD SONG
*/
mod = FMUSIC_LoadSong("../../media/invtro94.s3m");
if (!mod)
{
printf("%s\n", FMOD_ErrorString(FSOUND_GetError()));
exit(1);
}
FMUSIC_PlaySong(mod);
/*
UPDATE INTERFACE
*/
printf("Press any key to quit\n");
printf("=========================================================================\n");
printf("Playing %s...\n", FMUSIC_GetName(mod));
do
{
printf("order = %d/%d, row = %d/%d channels playing = %d cpu usage = %.02f%% \r", FMUSIC_GetOrder(mod), FMUSIC_GetNumOrders(mod), FMUSIC_GetRow(mod), FMUSIC_GetPatternLength(mod, FMUSIC_GetOrder(mod)), FSOUND_GetChannelsPlaying(), FSOUND_GetCPUUsage());
Sleep(10);
} while (!kbhit());
getch();
printf("\n");
/*
FREE SONG AND SHUT DOWN
*/
FMUSIC_FreeSong(mod);
FSOUND_Close();
return 0;
}
char CFMOD::PlayMusic(char* szFilename)
{
if(!bfmod) return 0;
StopMusic();
fmusic=FMUSIC_LoadSong(szFilename);
if(fmusic)
{
FMUSIC_SetMasterVolume(fmusic,mvol);
return FMUSIC_PlaySong(fmusic);
}
return 0;
}
//===========================================================================
// DM_FModExtStartPlaying
//===========================================================================
void DM_FModExtStartPlaying(void)
{
if(module)
{
FMUSIC_SetMasterVolume(module, ext_volume);
FMUSIC_PlaySong(module);
}
if(stream)
{
stream_channel = FSOUND_Stream_Play(FSOUND_FREE, stream);
}
// ext_playing = true;
// ext_start_time = Sys_GetTime();
}
u32 Gdl_playSong(u8* song,u32 size)
{ if(!song || !size) return 0;
if(!soundWasInit) Gdl_iniSound();
#ifdef useMiniFmod
MEMFILE mzk ;
mzk.pos=0 ;
mzk.length=size;
mzk.data=(char*)song;
gzk = FMUSIC_LoadSong((char*)&mzk,0);
if(gzk)
{ FMUSIC_PlaySong(gzk);
return 1;
}
#endif
return 0;
}
bool C4MusicFileMOD::Play(bool loop)
{
// Load Song
size_t iFileSize;
if (!C4Group_ReadFile(FileName, &Data, &iFileSize))
return false;
// init fmusic
mod = FMUSIC_LoadSongEx(Data, 0, iFileSize, FSOUND_LOADMEMORY, 0, 0);
if (!mod)
{
LogF("FMod: %s", FMOD_ErrorString(FSOUND_GetError()));
return false;
}
// Play Song
FMUSIC_PlaySong(mod);
return true;
}
BOOL C4MusicFileMOD::Play(BOOL loop)
{
// Load Song
size_t iFileSize;
if(!C4Group_ReadFile(FileName, &Data, &iFileSize))
return FALSE;
// init fmusic
mod = FMUSIC_LoadSongEx(Data, 0, iFileSize, FSOUND_LOADMEMORY, 0, 0);
if (!mod)
{
sprintf(OSTR, "FMod: %s", FMOD_ErrorString(FSOUND_GetError()));
Log(OSTR);
return FALSE;
}
// Play Song
FMUSIC_PlaySong(mod);
return TRUE;
}
/// <summary> Plays music </summary>
///
/// <param name="Index"> Music index </param>
void CSound::PlaYMID(int Index)
{
// Upon verifying the user has music enabled start playing song
if (p->Options->music == 1)
{
// Select the music based upon index
switch(Index)
{
case 0:
// Sets a songs master volume
FMUSIC_SetMasterVolume(m_BC1, 75);
// Starts a song playing
FMUSIC_PlaySong(m_BC1);
break;
case 1:
FMUSIC_SetMasterVolume(m_BC2, 75);
FMUSIC_PlaySong(m_BC2);
break;
case 2:
FMUSIC_SetMasterVolume(m_BC3, 75);
FMUSIC_PlaySong(m_BC3);
break;
case 3:
FMUSIC_SetMasterVolume(m_BC5, 75);
FMUSIC_PlaySong(m_BC5);
break;
case 4:
FMUSIC_SetMasterVolume(m_BC6, 75);
FMUSIC_PlaySong(m_BC6);
break;
case 5:
FMUSIC_SetMasterVolume(m_BC8, 75);
FMUSIC_PlaySong(m_BC8);
break;
case 6:
FMUSIC_SetMasterVolume(m_BC9, 75);
FMUSIC_PlaySong(m_BC9);
break;
}
}
}
bool C4MusicFileMID::Play(bool loop)
{
// check existance
if (!FileExists(FileName))
// try extracting it
if (!ExtractFile())
// doesn't exist - or file is corrupt
return false;
// init fmusic
mod = FMUSIC_LoadSong(SongExtracted ? Config.AtTempPath(C4CFN_TempMusic2) : FileName);
if (!mod)
{
LogF("FMod: %s", FMOD_ErrorString(FSOUND_GetError()));
return false;
}
// Play Song
FMUSIC_PlaySong(mod);
return true;
}
BOOL C4MusicFileMID::Play(BOOL loop)
{
// check existance
if(!FileExists(FileName))
// try extracting it
if(!ExtractFile())
// doesn't exist - or file is corrupt
return FALSE;
// init fmusic
mod = FMUSIC_LoadSong(SongExtracted ? Config.AtTempPath(C4CFN_TempMusic2) : FileName);
if (!mod)
{
sprintf(OSTR, "FMod: %s", FMOD_ErrorString(FSOUND_GetError()));
Log(OSTR);
return FALSE;
}
// Play Song
FMUSIC_PlaySong(mod);
return TRUE;
}
bool CSoundManager::PlaySong(int Nr, bool Paused)
{
if (false == InitSuccessfull)
return false;
if (its_Songs[Nr] == NULL)
return false;
if (Paused == false)
{
FMUSIC_PlaySong(its_Songs[Nr]->SongData); // Von vorne abspielen ?
its_Songs[Nr]->FadingVolume = 0.0f;
SetSongVolume(Nr, its_GlobalMusicVolume);
}
else
{
SetSongVolume(Nr, its_Songs[Nr]->Volume);
FMUSIC_SetPaused(its_Songs[Nr]->SongData, false); // oder Pause aufheben ?
}
CurrentSongNr = Nr;
return true;
} // PlaySong
glui32 glk_schannel_play_ext(schanid_t chan, glui32 snd, glui32 repeats, glui32 notify)
{
FILE *file;
long pos, len;
glui32 type;
char *buf;
int offset = 0;
int i;
if (!chan) {
gli_strict_warning("schannel_play_ext: invalid id.");
return 0;
}
/* stop previous noise */
glk_schannel_stop(chan);
if (repeats == 0)
return 1;
/* load sound resource into memory */
if (!giblorb_is_resource_map())
{
char name[1024];
sprintf(name, "%s/SND%ld", gli_workdir, snd);
file = fopen(name, "rb");
if (!file)
return 0;
fseek(file, 0, SEEK_END);
len = ftell(file);
buf = malloc(len);
if (!buf) {
fclose(file);
return 0;
}
fseek(file, 0, 0);
fread(buf, 1, len, file);
fclose(file);
/* identify by file magic the two types that fmod can do... */
type = 0; /* unidentified */
/* AIFF */
if (len > 4 && !memcmp(buf, "FORM", 4))
type = giblorb_ID_FORM;
/* WAVE */
if (len > 4 && !memcmp(buf, "WAVE", 4))
type = giblorb_ID_WAVE;
/* MIDI */
if (len > 4 && !memcmp(buf, "MThd", 4))
type = giblorb_ID_MIDI;
/* Ogg Vorbis */
if (len > 4 && !memcmp(buf, "OggS", 4))
type = giblorb_ID_OGG;
/* s3m */
if (len > 0x30 && !memcmp(buf + 0x2c, "SCRM", 4))
type = giblorb_ID_MOD;
/* XM */
if (len > 20 && !memcmp(buf, "Extended Module: ", 17))
type = giblorb_ID_MOD;
/* MOD */
if (len > 1084)
{
char resname[4];
memcpy(resname, buf + 1080, 4);
if (!strcmp(resname+1, "CHN") || /* 4CHN, 6CHN, 8CHN */
!strcmp(resname+2, "CN") || /* 16CN, 32CN */
!strcmp(resname, "M.K.") || !strcmp(resname, "M!K!") ||
!strcmp(resname, "FLT4") || !strcmp(resname, "CD81") ||
!strcmp(resname, "OKTA") || !strcmp(resname, " "))
type = giblorb_ID_MOD;
}
if (!memcmp(buf, "\377\372", 2)) /* mp3 */
type = giblorb_ID_MP3;
/* look for RIFF (future boy has broken resources...?) */
if (len > 128 && type == 0)
for (i = 0; i < 124; i++)
if (!memcmp(buf+i, "RIFF", 4))
{
offset = i;
type = giblorb_ID_WAVE;
break;
}
if (type == 0)
type = giblorb_ID_MP3;
}
else
{
giblorb_get_resource(giblorb_ID_Snd, snd, &file, &pos, &len, &type);
if (!file)
return 0;
buf = malloc(len);
if (!buf)
return 0;
fseek(file, pos, 0);
fread(buf, 1, len, file);
}
switch (type)
{
case giblorb_ID_FORM:
case giblorb_ID_WAVE:
case giblorb_ID_MP3:
chan->sample = FSOUND_Sample_Load(FSOUND_UNMANAGED, buf + offset,
FSOUND_NORMAL|FSOUND_LOADMEMORY, 0, len);
if (!chan->sample) { free(buf); return 0; }
if (repeats != 1)
FSOUND_Sample_SetMode(chan->sample, FSOUND_LOOP_NORMAL);
else
FSOUND_Sample_SetMode(chan->sample, FSOUND_LOOP_OFF);
chan->channel = FSOUND_PlaySound(FSOUND_FREE, chan->sample);
FSOUND_SetVolume(chan->channel, chan->volume / 256);
FSOUND_SetPaused(chan->channel, 0);
break;
case giblorb_ID_MOD:
case giblorb_ID_MIDI:
chan->module = FMUSIC_LoadSongEx(buf, 0, len, FSOUND_LOADMEMORY, 0, 0);
if (!chan->module) { free(buf); return 0; }
if (repeats != 1)
FMUSIC_SetLooping(chan->module, 1);
else
FMUSIC_SetLooping(chan->module, 0);
FMUSIC_SetMasterVolume(chan->module, chan->volume / 256);
FMUSIC_PlaySong(chan->module);
break;
default:
gli_strict_warning("schannel_play_ext: unknown resource type.");
}
free(buf);
return 1;
}
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
void main(int argc, char *argv[])
{
#ifdef USEFMOD
FMUSIC_MODULE *mod;
#ifndef USEMEMLOAD
FSOUND_File_SetCallbacks(fileopen, fileclose, fileread, fileseek, filetell);
#else
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
#endif
#endif
if (argc < 2)
{
printf("-------------------------------------------------------------\n");
printf("MINIFMOD example XM player.\n");
printf("Copyright (c) Firelight Technologies, 2000-2004.\n");
printf("-------------------------------------------------------------\n");
printf("Syntax: simplest infile.xm\n\n");
return;
}
#ifdef USEFMOD
#if USE_XAUDIO2_ENGINE
// Init FMod XAudio2 Driver
FMUSIC_XAudio2_Init();
#endif
// ==========================================================================================
// LOAD SONG
// ==========================================================================================
mod = FMUSIC_LoadSong(argv[1], NULL); //sampleloadcallback);
if (!mod)
{
printf("Error loading song\n");
return;
}
// ==========================================================================================
// PLAY SONG
// ==========================================================================================
FMUSIC_PlaySong(mod);
#endif
printf("Press Esc key to quit\n");
printf("=========================================================================\n");
printf("Playing song...\n");
{
char key = 0;
do
{
int ord = 0, row = 0;
float mytime = 0;
if (kbhit())
{
key = getch();
}
#ifdef USEFMOD
ord = FMUSIC_GetOrder(mod);
row = FMUSIC_GetRow(mod);
mytime = (float)FMUSIC_GetTime(mod) / 1000.0f;
#endif
printf("ord %2d row %2d seconds %5.02f %s \r", ord, row, mytime, (row % 8 ? " " : "TICK"));
} while (key != VK_ESCAPE);
}
printf("\n");
#ifdef USEFMOD
FMUSIC_FreeSong(mod);
#endif
}
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
void main(int argc, char *argv[])
{
#ifdef USEFMOD
FMUSIC_MODULE *mod;
#ifndef USEMEMLOAD
FSOUND_File_SetCallbacks(fileopen, fileclose, fileread, fileseek, filetell);
#else
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
#endif
#endif
if (argc < 2)
{
printf("-------------------------------------------------------------\n");
printf("MINIFMOD example XM player.\n");
printf("Copyright (c) Firelight Multimedia, 2000.\n");
printf("-------------------------------------------------------------\n");
printf("Syntax: simplest infile.xm\n\n");
return;
}
#ifdef USEFMOD
// ==========================================================================================
// INITIALIZE
// ==========================================================================================
if (!FSOUND_Init(44100, 0))
{
printf("Error upon initialization\n");
return;
}
// ==========================================================================================
// LOAD SONG
// ==========================================================================================
mod = FMUSIC_LoadSong(argv[1], NULL); //sampleloadcallback);
if (!mod)
{
printf("Error loading song\n");
return;
}
// ==========================================================================================
// PLAY SONG
// ==========================================================================================
FMUSIC_PlaySong(mod);
#endif
printf("Press any key to quit\n");
printf("=========================================================================\n");
printf("Playing song...\n");
{
char key = 0;
do
{
int ord = 0, row = 0;
float mytime = 0;
if (kbhit())
{
key = getch();
}
#ifdef USEFMOD
ord = FMUSIC_GetOrder(mod);
row = FMUSIC_GetRow(mod);
mytime = (float)FMUSIC_GetTime(mod) / 1000.0f;
#endif
printf("ord %2d row %2d seconds %5.02f %s \r", ord, row, mytime, (row % 8 ? " " : "TICK"));
} while (key != 27);
}
printf("\n");
#ifdef USEFMOD
FMUSIC_FreeSong(mod);
FSOUND_Close();
#endif
}
static inline VOID M_StartFMODSong(LPVOID data, int len, int looping, HWND hDlg)
{
const int loops = FSOUND_LOOP_NORMAL|FSOUND_LOADMEMORY;
const int nloop = FSOUND_LOADMEMORY;
M_FreeMusic();
if (looping)
mod = FMUSIC_LoadSongEx(data, 0, len, loops, NULL, 0);
else
mod = FMUSIC_LoadSongEx(data, 0, len, nloop, NULL, 0);
if (mod)
{
FMUSIC_SetLooping(mod, (signed char)looping);
FMUSIC_SetPanSeperation(mod, 0.0f);
}
else
{
if (looping)
fmus = FSOUND_Stream_Open(data, loops, 0, len);
else
fmus = FSOUND_Stream_Open(data, nloop, 0, len);
}
if (!fmus && !mod)
{
MessageBoxA(hDlg, FMOD_ErrorString(FSOUND_GetError()), "Error", MB_OK|MB_APPLMODAL);
return;
}
// Scan the OGG for the COMMENT= field for a custom loop point
if (looping && fmus)
{
const BYTE *origpos, *dataum = data;
size_t scan, size = len;
CHAR buffer[512];
BOOL titlefound = FALSE, artistfound = FALSE;
unsigned int loopstart = 0;
origpos = dataum;
for(scan = 0; scan < size; scan++)
{
if (!titlefound)
{
if (*dataum++ == 'T')
if (*dataum++ == 'I')
if (*dataum++ == 'T')
if (*dataum++ == 'L')
if (*dataum++ == 'E')
if (*dataum++ == '=')
{
size_t titlecount = 0;
CHAR title[256];
BYTE length = *(dataum-10) - 6;
while(titlecount < length)
title[titlecount++] = *dataum++;
title[titlecount] = '\0';
sprintf(buffer, "Title: %s", title);
SendMessage(GetDlgItem(hDlg, IDC_TITLE), WM_SETTEXT, 0, (LPARAM)(LPCSTR)buffer);
titlefound = TRUE;
}
}
}
dataum = origpos;
for(scan = 0; scan < size; scan++)
{
if (!artistfound)
{
if (*dataum++ == 'A')
if (*dataum++ == 'R')
if (*dataum++ == 'T')
if (*dataum++ == 'I')
if (*dataum++ == 'S')
if (*dataum++ == 'T')
if (*dataum++ == '=')
{
size_t artistcount = 0;
CHAR artist[256];
BYTE length = *(dataum-11) - 7;
while(artistcount < length)
artist[artistcount++] = *dataum++;
artist[artistcount] = '\0';
sprintf(buffer, "By: %s", artist);
SendMessage(GetDlgItem(hDlg, IDC_ARTIST), WM_SETTEXT, 0, (LPARAM)(LPCSTR)buffer);
artistfound = TRUE;
}
}
}
dataum = origpos;
for(scan = 0; scan < size; scan++)
{
if (*dataum++ == 'C'){
if (*dataum++ == 'O'){
if (*dataum++ == 'M'){
if (*dataum++ == 'M'){
if (*dataum++ == 'E'){
if (*dataum++ == 'N'){
if (*dataum++ == 'T'){
if (*dataum++ == '='){
if (*dataum++ == 'L'){
if (*dataum++ == 'O'){
if (*dataum++ == 'O'){
if (*dataum++ == 'P'){
if (*dataum++ == 'P'){
if (*dataum++ == 'O'){
if (*dataum++ == 'I'){
if (*dataum++ == 'N'){
if (*dataum++ == 'T'){
if (*dataum++ == '=')
{
size_t newcount = 0;
CHAR looplength[64];
while (*dataum != 1 && newcount < 63)
{
looplength[newcount++] = *dataum++;
}
looplength[newcount] = '\n';
loopstart = atoi(looplength);
}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
else
dataum--;}
}
if (loopstart > 0)
{
const int length = FSOUND_Stream_GetLengthMs(fmus);
const int freq = 44100;
const unsigned int loopend = (unsigned int)((freq/1000.0f)*length-(freq/1000.0f));
if (!FSOUND_Stream_SetLoopPoints(fmus, loopstart, loopend))
{
printf("FMOD(Start,FSOUND_Stream_SetLoopPoints): %s\n",
FMOD_ErrorString(FSOUND_GetError()));
}
}
}
if (mod)
FMUSIC_PlaySong(mod);
if (fmus)
fsoundchannel = FSOUND_Stream_PlayEx(FSOUND_FREE, fmus, NULL, FALSE);
M_SetVolume(128);
}
void playMusic(FMUSIC_MODULE *handle, bool loop)
{
FMUSIC_PlaySong(handle);
FMUSIC_SetMasterVolume(handle, DEF_VOLUME);
FMUSIC_SetLooping(handle, loop);
}
void init() {
GLUquadricObj *quadric;
int i, numInsts;
GLfloat position[] = {0.0f, 25.0f, -ZOOM*0.9, 1.0f};
GLfloat specular[] = {1.0f, 1.0f, 1.0f, 1.0f};
GLfloat ambient[] = {0.4f, 0.4f, 0.4f};
glClearColor(0.0, 0.0, 0.0, 1.0);
glClearDepth(1.0);
glDepthFunc(GL_LESS);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glEnable(GL_BLEND);
glLightfv(
GL_LIGHT0,
GL_POSITION,
position
);
glLightfv(
GL_LIGHT0,
GL_AMBIENT,
ambient
);
glLightfv(
GL_LIGHT0,
GL_SPECULAR,
specular
);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMateriali(GL_FRONT, GL_SHININESS, 255);
sphere = glGenLists(1);
glNewList(sphere, GL_COMPILE);
quadric = gluNewQuadric();
gluQuadricNormals(quadric, GLU_SMOOTH);
gluQuadricTexture(quadric, GL_FALSE);
gluSphere(quadric, RADIUS, 32, 32);
gluDeleteQuadric(quadric);
glEndList();
for(i = 0; i < DROPCOUNT; ++i)
drops[i].offset = -1;
FSOUND_Init(44100, 64, FSOUND_INIT_USEDEFAULTMIDISYNTH);
song = FMUSIC_LoadSong(SONG);
if(song == NULL)
song = FMUSIC_LoadSong("Obj\\" SONG);
FSOUND_DSP_SetActive(FSOUND_DSP_GetFFTUnit(), TRUE);
FMUSIC_SetMasterVolume(song, 256);
srand(0xDEADBEEF);
numInsts = FMUSIC_GetNumInstruments(song);
instrumentOffsets = (int *) malloc(sizeof(int) * numInsts);
for(i = 0; i < numInsts; ++i) {
FMUSIC_SetInstCallback(song, instrumentCallback, i);
instrumentOffsets[i] = rand() % (GRID_HEIGHT * GRID_WIDTH);
}
FMUSIC_PlaySong(song);
setText("STRAYLIGHT");
}
/*
[
[DESCRIPTION]
[PARAMETERS]
[RETURN_VALUE]
[REMARKS]
[SEE_ALSO]
]
*/
void main(int argc, char *argv[])
{
#ifdef USEFMOD
FMUSIC_MODULE *mod;
#ifndef USEMEMLOAD
FSOUND_File_SetCallbacks(fileopen, fileclose, fileread, fileseek, filetell);
#else
FSOUND_File_SetCallbacks(memopen, memclose, memread, memseek, memtell);
#endif
#endif
#ifdef USEFMOD
// ==========================================================================================
// LOAD SONG
// ==========================================================================================
mod = FMUSIC_LoadSong(MAKEINTRESOURCE(CHIPTUNE_MUS), NULL); //sampleloadcallback);
if (!mod)
{
printf("Error loading song\n");
return;
}
// ==========================================================================================
// PLAY SONG
// ==========================================================================================
FMUSIC_PlaySong(mod);
#endif
printf("Press any key to quit\n");
printf("=========================================================================\n");
printf("Playing song...\n");
{
char key = 0;
do
{
int ord = 0, row = 0;
float mytime = 0;
if (kbhit())
{
key = getch();
}
#ifdef USEFMOD
ord = FMUSIC_GetOrder(mod);
row = FMUSIC_GetRow(mod);
mytime = (float)FMUSIC_GetTime(mod) / 1000.0f;
#endif
printf("ord %2d row %2d seconds %5.02f %s \r", ord, row, mytime, (row % 8 ? " " : "TICK"));
} while (key != 27);
}
printf("\n");
#ifdef USEFMOD
FMUSIC_FreeSong(mod);
#endif
}
void cnsSynth_PlayMusic() { FMUSIC_PlaySong(mod); }
