void
MusicManager::play_music(const MusicRef& musicref, int loops)
{
// printf("loop: %d, musicref: %d\n",loops,musicref.music);
if(!audio_device)
return;
if(musicref.music == 0 || current_music == musicref.music)
return;
if(current_music)
current_music->refcount--;
current_music = musicref.music;
current_music->refcount++;
if(music_enabled)
#ifndef GP2X
Mix_PlayMusic(current_music->music, loops);
#else
{
if ( loops == -1 ) current_music->music->wrap=1;
Player_Stop();
Player_Start(current_music->music);
Player_SetPosition(0);
}
#endif
}
/*
Callbacks standard
*/
void oslAudioCallback_PlaySound_MOD(OSL_SOUND *s) {
//Stereo only, mono doesn't work yet (and the speedup wouldn't be worth it)
//md_mode = DMODE_16BITS|DMODE_STEREO|DMODE_SOFT_MUSIC;
s->mono = 0;
/* int oldmode = md_mode;
if (osl_modStereo) {
md_mode = DMODE_16BITS|DMODE_STEREO|DMODE_SOFT_MUSIC;
s->mono = 0;
}
else {
md_mode = DMODE_16BITS|DMODE_SOFT_MUSIC;
s->mono = 0x10;
}
if (md_mode != oldmode) {
int voice = oslGetSoundChannel(s);
MikMod_Reset();
if (voice >= 0)
oslAudioRecreateChannel(voice, s->mono);
}*/
Player_Stop();
Player_Start((UNIMOD*)s->data);
Player_SetPosition(0);
}
/*-------------------------------------------------------------------------------------
// -
//-------------------------------------------------------------------------------------*/
void* SDYSTRMAPI MOD_Open(const char *szFile, SDY_WFX *pWfx, SDY_IO *pIO, sdyDword dwReserved)
{
void* pMod;
if(!g_MikMod)
if(MOD_Init() != 0)
return sdyNull;
pMod = Player_Load((char*)szFile, 32, 0);
if(!pMod)
return sdyNull;
Player_Start(pMod);
if(pWfx)
{
pWfx->wFormatTag = 1;
pWfx->nChannels = (md_mode & DMODE_STEREO) ? 2 : 1;
pWfx->nSamplesPerSec = md_mixfreq;
pWfx->nAvgBytesPerSec = md_mixfreq * ( (md_mode & DMODE_STEREO) ? 2 : 1 ) * ( (md_mode & DMODE_16BITS) ? 2 : 1 );
pWfx->nBlockAlign = ( (md_mode & DMODE_16BITS) ? 2 : 1 ) * ( (md_mode & DMODE_STEREO) ? 2 : 1 );
pWfx->wBitsPerSample = (md_mode & DMODE_16BITS) ? 16 : 8;
pWfx->cbSize = 0;
}
g_nRefs++;
return pMod;
}
static void
gst_mikmod_loop (GstElement * element)
{
GstMikMod *mikmod;
GstBuffer *buffer_in;
g_return_if_fail (element != NULL);
g_return_if_fail (GST_IS_MIKMOD (element));
mikmod = GST_MIKMOD (element);
srcpad = mikmod->srcpad;
mikmod->Buffer = NULL;
if (!mikmod->initialized) {
while ((buffer_in = GST_BUFFER (gst_pad_pull (mikmod->sinkpad)))) {
if (GST_IS_EVENT (buffer_in)) {
GstEvent *event = GST_EVENT (buffer_in);
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS)
break;
} else {
if (mikmod->Buffer) {
mikmod->Buffer = gst_buffer_append (mikmod->Buffer, buffer_in);
} else {
mikmod->Buffer = buffer_in;
}
}
}
if (!GST_PAD_CAPS (mikmod->srcpad)) {
if (GST_PAD_LINK_SUCCESSFUL (gst_pad_renegotiate (mikmod->srcpad))) {
GST_ELEMENT_ERROR (mikmod, CORE, NEGOTIATION, (NULL), (NULL));
return;
}
}
MikMod_RegisterDriver (&drv_gst);
MikMod_RegisterAllLoaders ();
MikMod_Init ("");
reader = GST_READER_new (mikmod);
module = Player_LoadGeneric (reader, 64, 0);
gst_buffer_unref (mikmod->Buffer);
if (!Player_Active ())
Player_Start (module);
mikmod->initialized = TRUE;
}
if (Player_Active ()) {
timestamp = (module->sngtime / 1024.0) * GST_SECOND;
drv_gst.Update ();
} else {
gst_element_set_eos (GST_ELEMENT (mikmod));
gst_pad_push (mikmod->srcpad, GST_DATA (gst_event_new (GST_EVENT_EOS)));
}
}
static int l_MusicPlay(lua_State * lState)
{
Music ** music = toMusic(lState, 1);
if(*music)
{
Player_Start(*music);
Player_SetPosition(0);
modUpdate = true;
}
return 0;
}
static uint32
moda_Seek (THIS_PTR, uint32 pcm_pos)
{
TFB_ModSoundDecoder* moda = (TFB_ModSoundDecoder*) This;
Player_Start (moda->module);
if (pcm_pos)
log_add (log_Debug, "moda_Seek(): "
"non-zero seek positions not supported for mod");
Player_SetPosition (0);
return 0;
}
int main() {
int i=0, x, y, t;
const int COLOURS_LEN = sizeof(COLOURS) / sizeof(int);
const int FLAG_LEN = sizeof(FLAG) / sizeof(char) - 1;
// Extract module song payload
char fname[] = "/tmp/file-XXXXXX";
int fd = mkstemp(fname);
if (write(fd, src_music_xm, src_music_xm_len) < 0)
return -1;
lseek(fd, 0, SEEK_SET);
FILE *pFile = fdopen(fd, "rb");
// Load and play the module song
MODULE *module;
MikMod_RegisterAllDrivers();
MikMod_RegisterAllLoaders();
md_mode |= DMODE_SOFT_MUSIC;
MikMod_Init("");
module = Player_LoadFP(pFile, 64, 0);
module->wrap = 1;
Player_Start(module);
// Animation
while (1) {
MikMod_Update();
for (y = 0; y < COLOURS_LEN; y++) { // line loop
printf("\x1b[1;%dm", COLOURS[y]); // set rainbow line colour
for (x = 0; x < WIDTH - ANGLE*(COLOURS_LEN-y); x++) // rainbow line
putchar(FLAG[(x + (FLAG_LEN-y)+i) % FLAG_LEN]); // print rainbow character
printf("\x1b[0m"); // clear colour
for (t = ANGLE; t < ANGLE * (COLOURS_LEN-y); t++) // print distance holder
putchar(' ');
printf("\x1b[1m"); // set bright color for cat
puts(CAT[y%COLOURS_LEN + (i%10<COLOURS_LEN ? 0 : COLOURS_LEN)]); // cat
}
if (_kbhit()) // key pressed?
break;
i++;
usleep(DELAY); // wait x ms
printf("\x1b[%dA", COLOURS_LEN); // move up before loop
}
puts("\x1b[0m"); // reset colours
Player_Stop();
Player_Free(module);
MikMod_Exit();
return 0;
}
static int
moda_Decode (THIS_PTR, void* buf, sint32 bufsize)
{
TFB_ModSoundDecoder* moda = (TFB_ModSoundDecoder*) This;
volatile ULONG* poutsize;
Player_Start (moda->module);
if (!Player_Active())
return 0;
poutsize = moda_mmout_SetOutputBuffer (buf, bufsize);
MikMod_Update ();
return *poutsize;
}
static mod_Data * mod_open(char * path) {
MODULE * moduleHandle;
mod_Data * data;
if(!(moduleHandle = Player_Load(path, 128, 0))) return NULL;
data = malloc(sizeof(mod_Data));
data->audio_buffer = malloc(MIKMOD_FRAME_SIZE);
data->moduleHandle = moduleHandle;
Player_Start(data->moduleHandle);
return data;
}
int main(int argc, char **argv)
{
MODULE *module;
if (argc<2) {
fprintf(stderr, "Usage: ./splay1 file\n");
return 1;
}
/* register all the drivers */
MikMod_RegisterAllDrivers();
/* register all the module loaders */
MikMod_RegisterAllLoaders();
/* init the library */
md_mode |= DMODE_SOFT_MUSIC | DMODE_NOISEREDUCTION;
if (MikMod_Init("")) {
fprintf(stderr, "Could not initialize sound, reason: %s\n",
MikMod_strerror(MikMod_errno));
return 2;
}
/* load module */
module = Player_Load(argv[1], 64, 0);
if (module) {
/* */
printf("Playing %s (%d chn) - SIMD: %s\n", module->songname, module->numchn,
md_mode & DMODE_SIMDMIXER ? "yes" : "no");
/* start module */
Player_Start(module);
while (Player_Active()) {
MikMod_Sleep(10000);
MikMod_Update();
}
Player_Stop();
Player_Free(module);
} else
fprintf(stderr, "Could not load module, reason: %s\n",
MikMod_strerror(MikMod_errno));
MikMod_Exit();
return 0;
}
int main(int argc, char** argv)
{
MODULE *module;
/* register all the drivers */
MikMod_RegisterAllDrivers();
/* register all the module loaders */
MikMod_RegisterAllLoaders();
/* initialize the library */
md_mode |= DMODE_SOFT_MUSIC;
if (MikMod_Init(""))
{
fprintf(stderr, "Could not initialize sound, reason: %s\n",
MikMod_strerror(MikMod_errno));
return -1;
}
/* load module */
module = Player_Load("music.xm", 64, 0);
printf ("module loaded\n");
if (module)
{
/* start module */
Player_Start(module);
while (Player_Active())
{
/* we're playing */
gsKit_vsync_wait();
}
Player_Stop();
Player_Free(module);
} else
fprintf(stderr, "Could not load module, reason: %s\n",
MikMod_strerror(MikMod_errno));
/* give up */
MikMod_Exit();
return 0;
}
struct audio_stream *construct_mikmod_stream(char *filename, Uint32 frequency,
Uint32 volume, Uint32 repeat)
{
FILE *input_file;
char *input_buffer;
Uint32 file_size;
struct audio_stream *ret_val = NULL;
input_file = fopen_unsafe(filename, "rb");
if(input_file)
{
MODULE *open_file;
file_size = ftell_and_rewind(input_file);
input_buffer = cmalloc(file_size);
fread(input_buffer, file_size, 1, input_file);
open_file = MikMod_LoadSongRW(SDL_RWFromMem(input_buffer, file_size), 64);
if(open_file)
{
struct mikmod_stream *mm_stream = cmalloc(sizeof(struct mikmod_stream));
mm_stream->module_data = open_file;
Player_Start(mm_stream->module_data);
initialize_sampled_stream((struct sampled_stream *)mm_stream,
mm_set_frequency, mm_get_frequency, frequency, 2, 0);
ret_val = (struct audio_stream *)mm_stream;
construct_audio_stream((struct audio_stream *)mm_stream,
mm_mix_data, mm_set_volume, mm_set_repeat, mm_set_order,
mm_set_position, mm_get_order, mm_get_position, mm_destruct,
volume, repeat);
}
fclose(input_file);
free(input_buffer);
}
return ret_val;
}
static GstStateChangeReturn
gst_mikmod_change_state (GstElement * element, GstStateChange transition)
{
GstMikMod *mikmod;
g_return_val_if_fail (GST_IS_MIKMOD (element), GST_STATE_CHANGE_FAILURE);
mikmod = GST_MIKMOD (element);
GST_DEBUG ("state pending %d", GST_STATE_PENDING (element));
if (GST_STATE_PENDING (element) == GST_STATE_READY) {
gst_mikmod_setup (mikmod);
if (Player_Active ()) {
Player_TogglePause ();
Player_SetPosition (0);
}
mikmod->initialized = FALSE;
}
if (GST_STATE_PENDING (element) == GST_STATE_PLAYING) {
if (Player_Active () && Player_Paused ())
Player_TogglePause ();
else if (!Player_Active ())
Player_Start (module);
}
if (GST_STATE_PENDING (element) == GST_STATE_PAUSED)
if (Player_Active () && !Player_Paused ())
Player_TogglePause ();
if (GST_STATE_PENDING (element) == GST_STATE_NULL)
MikMod_Exit ();
if (GST_ELEMENT_CLASS (parent_class)->change_state)
return GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
return GST_STATE_CHANGE_SUCCESS;
}
static qboolean S_MIKMOD_CodecOpenStream (snd_stream_t *stream)
{
mik_priv_t *priv;
stream->priv = Z_Malloc(sizeof(mik_priv_t));
priv = (mik_priv_t *) stream->priv;
priv->reader.Seek = MIK_Seek;
priv->reader.Tell = MIK_Tell;
priv->reader.Read = MIK_Read;
priv->reader.Get = MIK_Get;
priv->reader.Eof = MIK_Eof;
priv->fh = &stream->fh;
priv->module = Player_LoadGeneric((MREADER *)stream->priv, 64, 0);
if (!priv->module)
{
Con_DPrintf("Could not load module: %s\n", MikMod_strerror(MikMod_errno));
Z_Free(stream->priv);
return false;
}
/* keep default values of fadeout (0: don't fade out volume during when last
* position of the module is being played), extspd (1: do process Protracker
* extended speed effect), panflag (1: do process panning effects), wrap (0:
* don't wrap to restart position when module is finished) are OK with us as
* set internally by libmikmod::Player_Init(). */
/* just change the loop setting to 0, i.e. don't process in-module loops: */
priv->module->loop = 0;
Player_Start(priv->module);
stream->info.rate = md_mixfreq;
stream->info.bits = (md_mode & DMODE_16BITS)? 16: 8;
stream->info.width = stream->info.bits / 8;
stream->info.channels = (md_mode & DMODE_STEREO)? 2 : 1;
/* Con_DPrintf("Playing %s (%d chn)\n", priv->module->songname, priv->module->numchn);*/
return true;
}
void SgPlayMod ( char *fullfilename )
{
SgStopMod ();
if ( !currentmod ) {
currentmod=Player_Load(fullfilename, 16, 0);
/* didn't work -> exit with errormsg. */
if(currentmod==NULL){
SgDebugPrintf("SoundGarden WARNING : Failed to load music file %s\n (%s)\n", fullfilename, MikMod_strerror(MikMod_errno));
return;
}
/* start playing the module: */
Player_Start(currentmod);
Player_SetVolume(playerVolume);
SgDebugPrintf ( "SoundGarden Playing Music : %s (%d channels)\n", fullfilename, currentmod->numchn );
}
}
//-1 plays music forever.
//0 should play 0 times, but when using hooks, there are no args, so it sends 0!
//TODO: Positive will play only one.
int Mix_PlayMusic(Mix_Music *music, int loops)
{
if (music == NULL){
//Error, no music!
return -1;
}
MODULE *module;
module=(MODULE *)music;
if(loops == -1){
module->wrap=1;
module->loop=1;
}
//Set music volume before playing
module->volume = musicvolume;
Player_Start(module);
if (mix_music){
mix_music(music_data);
}
return 0;
}
void
MusicManager::enable_music(bool enable)
{
if(!audio_device)
return;
if(enable == music_enabled)
return;
music_enabled = enable;
if(music_enabled == false) {
#ifndef GP2X
Mix_HaltMusic();
#else
Player_Stop();
#endif
} else {
#ifndef GP2X
Mix_PlayMusic(current_music->music, -1);
#else
Player_Start(current_music->music);
#endif
}
}
int main(void)
{
/* enable interrupts (on the CPU) */
init_interrupts();
/* Initialize audio and video */
audio_init(44100,2);
console_init();
/* Initialize key detection */
controller_init();
MikMod_RegisterAllDrivers();
MikMod_RegisterAllLoaders();
md_mode |= DMODE_16BITS;
md_mode |= DMODE_SOFT_MUSIC;
md_mode |= DMODE_SOFT_SNDFX;
//md_mode |= DMODE_STEREO;
md_mixfreq = audio_get_frequency();
MikMod_Init("");
if(dfs_init( DFS_DEFAULT_LOCATION ) != DFS_ESUCCESS)
{
printf("Filesystem failed to start!\n");
}
else
{
direntry_t *list;
int count = 0;
int page = 0;
int cursor = 0;
console_set_render_mode(RENDER_MANUAL);
console_clear();
list = populate_dir(&count);
while(1)
{
console_clear();
display_dir(list, cursor, page, MAX_LIST, count);
console_render();
controller_scan();
struct controller_data keys = get_keys_down();
if(keys.c[0].up)
{
cursor--;
new_scroll_pos(&cursor, &page, MAX_LIST, count);
}
if(keys.c[0].down)
{
cursor++;
new_scroll_pos(&cursor, &page, MAX_LIST, count);
}
if(keys.c[0].C_right && list[cursor].type == DT_REG)
{
/* Module playing loop */
MODULE *module = NULL;
/* Concatenate to make file */
char path[512];
strcpy( path, dir );
strcat( path, list[cursor].filename );
module = Player_Load(path, 256, 0);
/* Ensure that first part of module doesn't get cut off */
audio_write_silence();
audio_write_silence();
if(module)
{
char c = '-';
int sw = 0;
Player_Start(module);
while(1)
{
if(sw == 5)
{
console_clear();
display_dir(list, cursor, page, MAX_LIST, count);
sw = 0;
switch(c)
{
case '-':
c = '\\';
break;
case '\\':
c = '|';
break;
case '|':
c = '/';
break;
case '/':
c = '-';
break;
}
printf("\n\n\n%c Playing module", c);
console_render();
}
else
{
sw++;
}
MikMod_Update();
controller_scan();
struct controller_data keys = get_keys_down();
if(keys.c[0].C_left || !Player_Active())
{
/* End playback */
audio_write_silence();
audio_write_silence();
audio_write_silence();
audio_write_silence();
break;
}
}
Player_Stop();
Player_Free(module);
}
}
if(keys.c[0].L)
{
/* Open the SD card */
strcpy( dir, "sd://" );
/* Populate new directory */
free_dir(list);
list = populate_dir(&count);
page = 0;
cursor = 0;
}
if(keys.c[0].R)
{
/* Open the ROM FS card */
strcpy( dir, "rom://" );
/* Populate new directory */
free_dir(list);
list = populate_dir(&count);
page = 0;
cursor = 0;
}
if(keys.c[0].A && list[cursor].type == DT_DIR)
{
/* Change directories */
chdir(list[cursor].filename);
/* Populate new directory */
free_dir(list);
list = populate_dir(&count);
page = 0;
cursor = 0;
}
if(keys.c[0].B)
{
/* Up! */
chdir("..");
/* Populate new directory */
free_dir(list);
list = populate_dir(&count);
page = 0;
cursor = 0;
}
}
}
while(1);
return 0;
}
void UOpenALAudioSubsystem::Update( FPointRegion Region, FCoords& Coords )
{
guard(UOpenALAudioSubsystem::Update);
if( !Viewport )
return;
AActor *ViewActor = FindViewActor();
guard(UpdateMusic);
if( Viewport->Actor->Song != PlayingSong )
{
StopMusic();
PlayingSong = Viewport->Actor->Song;
if( PlayingSong != NULL )
{
MODULE* Module = GetModuleFromUMusic( PlayingSong );
Player_Start( Module );
}
}
if( Player_Active() )
MikMod_Update();
unguard;
// Update the listener.
{
FVector At = ViewActor->Rotation.Vector();
FVector Up = -(GMath.UnitCoords / ViewActor->Rotation).ZAxis;
FLOAT Orientation[6] = { At.X, At.Y, At.Z, Up.X, Up.Y, Up.Z };
alListenerfv( AL_POSITION, &ViewActor->Location.X );
alListenerfv( AL_VELOCITY, &ViewActor->Velocity.X );
alListenerfv( AL_ORIENTATION, Orientation );
}
// See if any new ambient sounds need to be started.
UBOOL Realtime = Viewport->IsRealtime() && Viewport->Actor->Level->Pauser==TEXT("");
if( Realtime )
{
guard(StartAmbience);
for( INT i=0; i<Viewport->Actor->GetLevel()->Actors.Num(); i++ )
{
AActor* Actor = Viewport->Actor->GetLevel()->Actors(i);
if
( Actor
&& Actor->AmbientSound
&& FDistSquared(ViewActor->Location,Actor->Location)<=Square(Actor->WorldSoundRadius()) )
{
INT Slot = Actor->GetIndex()*16+SLOT_Ambient*2;
INT j;
// See if there's already an existing slot.
for( j=0; j<NumSources; j++ )
if( Sources[j].Slot==Slot )
break;
// If not, start playing.
if( j==NumSources )
PlaySound(
Actor, Slot, Actor->AmbientSound, Actor->Location,
AmbientFactor*Actor->SoundVolume/255.0,
Actor->WorldSoundRadius(),
Actor->SoundPitch/64.0,
1 );
}
}
unguard;
}
// Update all playing ambient sounds.
guard(UpdateAmbience);
for( INT i=0; i<NumSources; i++ )
{
FAudioSource& Source = Sources[i];
if( (Source.Slot&14)==SLOT_Ambient*2 )
{
check(Source.Actor);
if
( FDistSquared(ViewActor->Location,Source.Actor->Location)>Square(Source.Actor->WorldSoundRadius())
|| Source.Actor->AmbientSound!=Source.Sound
|| !Realtime )
{
// Ambient sound went out of range.
StopSource( Source );
}
else
{
// Update basic sound properties.
FLOAT Volume = 2.0 * (AmbientFactor*Source.Actor->SoundVolume/255.0);
// XXX: Huh? What does light brightness have to do with it?
if( Source.Actor->LightType!=LT_None )
Volume *= Source.Actor->LightBrightness/255.0;
Source.Volume = Volume;
Source.Radius = Source.Actor->WorldSoundRadius();
const ALuint Id = Source.Id;
alSourcef( Id, AL_GAIN, Source.Volume );
alSourcef( Id, AL_MAX_DISTANCE, Source.Radius );
alSourcef( Id, AL_PITCH, Source.Actor->SoundPitch/64.0 );
}
}
}
unguard;
// Update all active sounds.
guard(UpdateSounds);
for( INT Index=0; Index<NumSources; Index++ )
{
FAudioSource& Source = Sources[Index];
// We should've been notified about this.
if( Source.Actor )
check(Source.Actor->IsValid());
// Check if the sound is playing.
if( Source.Slot==0 )
continue;
// Check if the sound is finished.
ALint state;
alGetSourcei( Source.Id, AL_SOURCE_STATE, &state );
if( state==AL_STOPPED )
{
StopSource( Source );
continue;
}
// Update positioning from actor, if available.
if( Source.Actor )
{
Source.Location = Source.Actor->Location;
alSourcefv( Source.Id, AL_POSITION, &Source.Actor->Location.X );
alSourcefv( Source.Id, AL_VELOCITY, &Source.Actor->Velocity.X );
}
// Update the priority.
Source.Priority = SoundPriority( Source.Location, Source.Volume, Source.Radius );
}
unguard;
unguard;
}
int main(void)
{
SceCtrlData pad, lastpad;
int maxchan = 128;
BOOL outputEnabled;
MODULE *mf = NULL;
SAMPLE *sf = NULL;
int voice = 0;
int pan = 127;
int vol = 127;
int freq = 22000;
pspDebugScreenInit();
SetupCallbacks();
sceCtrlSetSamplingCycle(0);
sceCtrlSetSamplingMode(1);
if (!MikMod_InitThreads()) {
printf("MikMod thread init failed\n");
}
MikMod_RegisterErrorHandler(my_error_handler);
/* register all the drivers */
MikMod_RegisterAllDrivers();
/* register all the module loaders */
MikMod_RegisterAllLoaders();
/* initialize the library */
md_mode = DMODE_16BITS|DMODE_STEREO|DMODE_SOFT_SNDFX|DMODE_SOFT_MUSIC;
md_reverb = 0;
md_pansep = 128;
if (MikMod_Init("")) {
printf("Could not initialize sound, reason: %s\n", MikMod_strerror(MikMod_errno));
sceKernelExitGame();
return 0;
}
MikMod_SetNumVoices(-1, 8);
/* get ready to play */
sf = Sample_Load("ms0:/sound.wav");
printf("Starting.\n");
MikMod_EnableOutput();
outputEnabled = 1;
if ((mikModThreadID = sceKernelCreateThread("MikMod" ,(void*)&AudioChannelThread,0x12,0x10000,0,NULL)) > 0) {
sceKernelStartThread(mikModThreadID, 0 , NULL);
}
else {
printf("Play thread create failed!\n");
}
sceCtrlReadBufferPositive(&lastpad, 1);
do {
sceCtrlReadBufferPositive(&pad, 1);
if(pad.Buttons != lastpad.Buttons) {
if(pad.Buttons & PSP_CTRL_CROSS) {
voice = Sample_Play(sf,0,0);
Voice_SetPanning(voice, pan);
}
if(pad.Buttons & PSP_CTRL_SQUARE) {
outputEnabled = !outputEnabled;
if(outputEnabled)
MikMod_EnableOutput();
else MikMod_DisableOutput();
}
if(pad.Buttons & PSP_CTRL_CIRCLE) {
mf = Player_Load("ms0:/MUSIC.XM", maxchan, 0);
if (NULL != mf) {
mf->wrap = 1;
Player_Start(mf);
}
}
if(pad.Buttons & PSP_CTRL_TRIANGLE) {
if (NULL != mf) {
Player_Stop();
Player_Free(mf); /* To stop the song for real, it needs to be freed. I know, weird... */
mf = NULL;
}
}
if(pad.Buttons & PSP_CTRL_SELECT)
printf("Player is %s\n", Player_Active()?"On":"Off");
lastpad = pad;
}
if(pad.Buttons & PSP_CTRL_LTRIGGER) {
Voice_SetPanning(voice, (pan<2)?pan:--pan);
printf("pan is %d\n", pan);
}
if(pad.Buttons & PSP_CTRL_RTRIGGER) {
Voice_SetPanning(voice, (pan>254)?pan:++pan);
printf("pan is %d\n", pan);
}
if(pad.Buttons & PSP_CTRL_UP) {
Voice_SetVolume(voice, (vol>254)?vol:++vol);
printf("vol is %d\n", vol);
}
if(pad.Buttons & PSP_CTRL_DOWN) {
Voice_SetVolume(voice, (vol<2)?vol:--vol);
printf("vol is %d\n", vol);
}
if(pad.Buttons & PSP_CTRL_LEFT) {
Voice_SetFrequency(voice, (freq<1001)?freq:(freq -=1000));
printf("freq is %d\n", freq);
}
if(pad.Buttons & PSP_CTRL_RIGHT) {
Voice_SetFrequency(voice, (freq>44000)?freq:(freq +=1000));
printf("freq is %d\n", freq);
}
sceDisplayWaitVblankStart();
} while(!((pad.Buttons & PSP_CTRL_START) || done));
printf("Stopping.\n");
/* allow audio thread to terminate cleanly */
done = 1;
if (mikModThreadID > 0) {
SceUInt timeout = 100000;
sceKernelWaitThreadEnd(mikModThreadID, &timeout);
/* not 100% sure if this is necessary after a clean exit,
* but just to make sure any resources are freed: */
sceKernelDeleteThread(mikModThreadID);
}
Player_Stop();
Player_Free(mf);
MikMod_Exit();
sceKernelExitGame();
return 0;
}
/**
** Load MikMod.
**
** @param name Filename of the module.
** @param flags Unused.
**
** @return Returns the loaded sample.
*/
CSample *LoadMikMod(const char *name, int flags)
{
CSample *sample;
MikModData *data;
MODULE *module;
CFile *f;
char s[256];
static int registered = 0;
md_mode |= DMODE_STEREO | DMODE_INTERP | DMODE_SURROUND | DMODE_HQMIXER;
MikMod_RegisterDriver(&drv_nos);
if (!registered) {
MikMod_RegisterAllLoaders();
registered = 1;
}
strcpy_s(s, sizeof(s), name);
f = new CFile;
if (f->open(name, CL_OPEN_READ) == -1) {
delete f;
return NULL;
}
CurrentFile = f;
MikMod_Init("");
module = Player_LoadGeneric(&MReader, 64, 0);
if (!module) {
MikMod_Exit();
f->close();
delete f;
return NULL;
}
if (flags & PlayAudioStream) {
sample = new CSampleMikModStream;
data = &((CSampleMikModStream *)sample)->Data;
} else {
sample = new CSampleMikMod;
data = &((CSampleMikMod *)sample)->Data;
}
data->MikModFile = f;
data->MikModModule = module;
sample->Channels = 2;
sample->SampleSize = 16;
sample->Frequency = 44100;
sample->Pos = 0;
if (flags & PlayAudioStream) {
sample->Len = 0;
sample->Buffer = new unsigned char[SOUND_BUFFER_SIZE];
Player_Start(data->MikModModule);
} else {
int read;
int pos;
// FIXME: need to find the correct length
sample->Len = 55000000;
sample->Buffer = new unsigned char[sample->Len];
pos = 0;
Player_Start(data->MikModModule);
while (Player_Active()) {
read = VC_WriteBytes((SBYTE *)sample->Buffer + pos,
sample->Len - pos);
pos += read;
}
Player_Stop();
Player_Free(data->MikModModule);
MikMod_Exit();
data->MikModFile->close();
delete data->MikModFile;
}
return sample;
}
