// PlayRMF()
// ---------------------------------------------------------------------
//
//
BAEResult PlayRMF(BAEMixer theMixer, char *fileName)
{
BAEResult err;
BAESong theSong = BAESong_New(theMixer);
BAE_BOOL done;
if (theSong)
{
err = BAESong_LoadRmfFromFile(theSong, (BAEPathName)fileName, 0, TRUE);
if (err == BAE_NO_ERROR)
{
err = BAESong_Start(theSong, 0);
if (err == BAE_NO_ERROR)
{
printf("BAE memory used for everything %ld\n\n", BAE_GetSizeOfMemoryUsed());
done = FALSE;
while (done == FALSE)
{
BAESong_IsDone(theSong, &done);
if (done == FALSE)
{
BAE_WaitMicroseconds(15000);
}
}
BAE_WaitMicroseconds(900000);
}
else printf("playrmf: Couldn't start song (BAE Error #%d)\n", err);
}
else printf("playrmf: Couldn't open RMF file '%s' (BAE Error #%d)\n", fileName, err);
}
else
{
err = BAE_MEMORY_ERR;
}
BAESong_Delete(theSong);
return err;
}
// DoFunction()
// -----------------------------------------------------
//
//
static void PV_DoFunction(int subMenu)
{
long slot;
long tmpLong1, tmpLong2, tmpLong3, tmpLong4, tmpLong5;
unsigned char tmpChar1, tmpChar2;
double tmpDouble1, tmpDouble2, tmpDouble3;
BAE_UNSIGNED_FIXED tmpUFixed;
BAE_BOOL tmpBool;
char tmpBuffer[256];
FILE *filePtr = NULL;
static void *bufferPtr = NULL;
BAEResult err;
err = BAE_NO_ERROR;
while (((slot=GetLong("Slot? (0-3) > "))<0) || (slot>=MAX_SLOTS))
{
printf("Try again. Choose a slot between 0 and %d\n", MAX_SLOTS-1);
}
switch (subMenu)
{
case FUNC_NEW:
// BAESong_New(BAEMixer mixer);
{
if (gSongs[slot])
{
printf(": Deleting old song in slot %d...\n", slot);
BAESong_Delete(gSongs[slot]);
gSongs[slot] = NULL;
}
gSongs[slot] = BAESong_New(gMixer);
if (gSongs[slot] != NULL)
{
printf(": New BAESong in slot %d.\n", slot);
}
else
{
printf(": BAESong_New() returned NULL\n");
}
}
break;
case FUNC_DELETE:
// BAESong_Delete(BAESong song);
{
err = BAESong_Delete(gSongs[slot]);
if (!err) gSongs[slot] = NULL;
}
break;
case FUNC_SET_VOLUME:
// BAESong_SetVolume(BAESong song, BAE_UNSIGNED_FIXED volume);
{
tmpDouble1 = GetDouble("Volume (1.0 norm) > ");
err = BAESong_SetVolume(gSongs[slot], FLOAT_TO_UNSIGNED_FIXED(tmpDouble1));
}
break;
case FUNC_GET_VOLUME:
// BAESong_GetVolume(BAESong song, BAE_UNSIGNED_FIXED *outVolume);
{
err = BAESong_GetVolume(gSongs[slot], &tmpUFixed);
if (!err) printf(": volume = %g\n", UNSIGNED_FIXED_TO_FLOAT(tmpUFixed));
}
break;
case FUNC_DOES_CHANNEL_ALLOW_TRANSPOSE:
// BAESong_DoesChannelAllowTranspose(BAESong song, unsigned short int channel, BAE_BOOL *outAllowTranspose);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_DoesChannelAllowTranspose(gSongs[slot], (unsigned short)tmpLong1, &tmpBool);
if (!err)
{
printf(": Channel %ld does ", tmpLong1);
if (!tmpBool) printf("NOT ");
printf("allow transpose\n");
}
}
break;
case FUNC_ALLOW_CHANNEL_TRANSPOSE:
// BAESong_AllowChannelTranspose(BAESong song, unsigned short int channel, BAE_BOOL allowTranspose);
{
tmpLong1 = GetLong("Channel > ");
tmpBool = (BAE_BOOL)GetBool("Allow transpose? (y/n) > ");
err = BAESong_AllowChannelTranspose(gSongs[slot], (unsigned short)tmpLong1, tmpBool);
}
break;
case FUNC_SET_TRANSPOSE:
// BAESong_SetTranspose(BAESong song, long semitones);
{
tmpLong1 = GetLong("Transpose semitones > ");
err = BAESong_SetTranspose(gSongs[slot], tmpLong1);
}
break;
case FUNC_GET_TRANSPOSE:
// BAESong_GetTranspose(BAESong song, long *outSemitones);
{
tmpLong1 = 0;
err = BAESong_GetTranspose(gSongs[slot], &tmpLong1);
if (!err) printf(": Transpose = %ld semitones\n", tmpLong1);
}
break;
case FUNC_MUTE_CHANNEL:
// BAESong_MuteChannel(BAESong song, unsigned short int channel);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_MuteChannel(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_UNMUTE_CHANNEL:
// BAESong_UnmuteChannel(BAESong song, unsigned short int channel);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_UnmuteChannel(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_GET_CHANNEL_MUTE_STATUS:
// BAESong_GetChannelMuteStatus(BAESong song, BAE_BOOL *outChannels);
{
BAE_BOOL result[16];
int i;
err = BAESong_GetChannelMuteStatus(gSongs[slot], result);
if (!err)
{
printf("channel: 0123456789ABCDEF\n");
printf("mute status: ");
for (i=0; i<16; i++)
{
printf("%d", (int)result[i]);
}
printf("\n");
}
}
break;
case FUNC_SOLO_CHANNEL:
// BAESong_SoloChannel(BAESong song, unsigned short int channel);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_SoloChannel(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_UNSOLO_CHANNEL:
// BAESong_UnSoloChannel(BAESong song, unsigned short int channel);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_UnSoloChannel(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_GET_CHANNEL_SOLO_STATUS:
// BAESong_GetChannelSoloStatus(BAESong song, BAE_BOOL *outChannels);
{
BAE_BOOL result[16];
int i;
err = BAESong_GetChannelSoloStatus(gSongs[slot], result);
if (!err)
{
printf("channel: 0123456789ABCDEF\n");
printf("solo status: ");
for (i=0; i<16; i++)
{
printf("%d", (int)result[i]);
}
printf("\n");
}
}
break;
case FUNC_LOAD_INSTRUMENT:
// BAESong_LoadInstrument(BAESong song, BAE_INSTRUMENT instrument);
{
tmpLong1 = GetLong("Instrument > ");
err = BAESong_LoadInstrument(gSongs[slot], tmpLong1);
}
break;
case FUNC_UNLOAD_INSTRUMENT:
// BAESong_UnloadInstrument(BAESong song, BAE_INSTRUMENT instrument);
{
tmpLong1 = GetLong("Instrument > ");
err = BAESong_UnloadInstrument(gSongs[slot], tmpLong1);
}
break;
case FUNC_IS_INSTRUMENT_LOADED:
// BAESong_IsInstrumentLoaded(BAESong song, BAE_INSTRUMENT instrument, BAE_BOOL *outIsLoaded);
{
tmpLong1 = GetLong("Instrument > ");
err = BAESong_IsInstrumentLoaded(gSongs[slot], tmpLong1, &tmpBool);
if (!err) printf(": Is Loaded = %d\n", (int)tmpBool);
}
break;
case FUNC_GET_CONTROL_VALUE:
// BAESong_GetControlValue(BAESong song, unsigned char channel, unsigned char controller, char *outValue);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Controller > ");
err = BAESong_GetControlValue(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (char *)&tmpChar1);
if (!err) printf(": Value = %ld\n", tmpChar1);
}
break;
case FUNC_GET_PROGRAM_BANK:
// BAESong_GetProgramBank(BAESong song, unsigned char channel, unsigned char *outProgram, unsigned char *outBank);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_GetProgramBank(gSongs[slot], (unsigned char)tmpLong1, &tmpChar1, &tmpChar2);
if (!err) printf(": Program = %ld, bank = %ld\n", tmpChar1, tmpChar2);
}
break;
case FUNC_GET_PITCH_BEND:
// BAESong_GetPitchBend(BAESong song, unsigned char channel, unsigned char *outLSB, unsigned char *outMSB);
{
tmpLong1 = GetLong("Channel > ");
err = BAESong_GetPitchBend(gSongs[slot], (unsigned char)tmpLong1, &tmpChar1, &tmpChar2);
if (!err) printf(": LSB = %ld, MSB = %ld\n", tmpChar1, tmpChar2);
}
break;
case FUNC_PARSE_MIDI_DATA:
// BAESong_ParseMidiData(BAESong song, unsigned char commandByte, unsigned char data1Byte, unsigned char data2Byte, unsigned char data3Byte, unsigned long time);
{
tmpLong1 = GetLong("Command byte > ");
tmpLong2 = GetLong("Data 1 byte > ");
tmpLong3 = GetLong("Data 2 byte > ");
tmpLong4 = GetLong("Data 3 byte > ");
tmpLong5 = GetLong("Time > ");
err = BAESong_ParseMidiData(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned char)tmpLong4, (unsigned long)tmpLong5);
}
break;
case FUNC_NOTE_OFF:
// BAESong_NoteOff(BAESong song, unsigned char channel, unsigned char note, unsigned char velocity, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Note > ");
tmpLong3 = GetLong("Velocity > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_NoteOff(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_NOTE_ON_WITH_LOAD:
// BAESong_NoteOnWithLoad(BAESong song, unsigned char channel, unsigned char note, unsigned char velocity, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Note > ");
tmpLong3 = GetLong("Velocity > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_NoteOnWithLoad(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_NOTE_ON:
// BAESong_NoteOn(BAESong song, unsigned char channel, unsigned char note, unsigned char velocity, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Note > ");
tmpLong3 = GetLong("Velocity > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_NoteOn(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_KEY_PRESSURE:
// BAESong_KeyPressure(BAESong song, unsigned char channel, unsigned char note, unsigned char pressure, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Note > ");
tmpLong3 = GetLong("Pressure > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_KeyPressure(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_CONTROL_CHANGE:
// BAESong_ControlChange(BAESong song, unsigned char channel, unsigned char controlNumber, unsigned char controlValue, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Control number > ");
tmpLong3 = GetLong("Control value > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_ControlChange(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_PROGRAM_BANK_CHANGE:
// BAESong_ProgramBankChange(BAESong song, unsigned char channel, unsigned char programNumber, unsigned char bankNumber, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Program > ");
tmpLong3 = GetLong("Bank > ");
tmpLong4 = GetLong("Time > ");
err = BAESong_ProgramBankChange(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned char)tmpLong3, (unsigned long)tmpLong4);
}
break;
case FUNC_PROGRAM_CHANGE:
// BAESong_ProgramChange(BAESong song, unsigned char channel, unsigned char programNumber, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Program > ");
tmpLong3 = GetLong("Time > ");
err = BAESong_ProgramChange(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned long)tmpLong3);
}
break;
case FUNC_CHANNEL_PRESSURE:
// BAESong_ChannelPressure(BAESong song, unsigned char channel, unsigned char pressure, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("Pressure > ");
tmpLong3 = GetLong("Time > ");
err = BAESong_ChannelPressure(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned long)tmpLong3);
}
break;
case FUNC_PITCH_BEND:
// BAESong_PitchBend(BAESong song, unsigned char channel, unsigned char lsb, unsigned char msb, unsigned long time);
{
tmpLong1 = GetLong("Channel > ");
tmpLong2 = GetLong("LSB > ");
tmpLong3 = GetLong("MSB > ");
err = BAESong_ProgramChange(gSongs[slot], (unsigned char)tmpLong1, (unsigned char)tmpLong2, (unsigned long)tmpLong3);
}
break;
case FUNC_ALL_NOTES_OFF:
// BAESong_AllNotesOff(BAESong song, unsigned long time);
{
tmpLong1 = GetLong("Time > ");
err = BAESong_AllNotesOff(gSongs[slot], (unsigned long)tmpLong1);
}
break;
case FUNC_LOAD_GROOVOID:
// BAESong_LoadGroovoid(BAESong song, char *cName, BAE_BOOL ignoreBadInstruments);
{
GetLine("Name > ", tmpBuffer, 256);
tmpBool = GetBool("Ignore bad instruments? (y/n) > ");
err = BAESong_LoadGroovoid(gSongs[slot], tmpBuffer, tmpBool);
}
break;
case FUNC_LOAD_MIDI_FROM_MEMORY:
// BAESong_LoadMidiFromMemory(BAESong song, void const* pMidiData, unsigned long midiSize, BAE_BOOL ignoreBadInstruments);
{
GetLine("Filepath > ", tmpBuffer, 256);
if (bufferPtr)
{
free(bufferPtr);
bufferPtr = NULL;
}
filePtr = fopen(tmpBuffer, "rb");
if (filePtr != NULL)
{
// Find the length of the file
fseek(filePtr, 0, SEEK_END);
tmpLong1 = ftell(filePtr);
// Return to the beginning
fseek(filePtr, 0, SEEK_SET);
// Now blast everything to a malloc'd buffer
bufferPtr = malloc((size_t) tmpLong1);
tmpLong2 = fread(bufferPtr, sizeof(char), tmpLong1, filePtr);
if (tmpLong2 != tmpLong1)
{
/// Yikes, we have an anomaly -- could check ferror...
printf("ERROR: File read error -- not BAE related...\n");
}
else
{
err = BAESong_LoadMidiFromMemory(gSongs[slot],
bufferPtr,
tmpLong2,
TRUE);
}
fclose(filePtr);
}
else
{
printf("ERROR: Couldn't find file to open into memory -- not BAE related...\n");
}
}
break;
case FUNC_LOAD_MIDI_FROM_FILE:
// BAESong_LoadMidiFromFile(BAESong song, BAEPathName filePath, BAE_BOOL ignoreBadInstruments);
{
GetLine("Filepath > ", tmpBuffer, 256);
tmpBool = GetBool("Ignore bad instruments? (y/n) > ");
err = BAESong_LoadMidiFromFile(gSongs[slot], tmpBuffer, tmpBool);
}
break;
case FUNC_LOAD_RMF_FROM_MEMORY:
// BAESong_LoadRmfFromMemory(BAESong song, void *pRMFData, unsigned long rmfSize, short int songIndex, BAE_BOOL ignoreBadInstruments);
{
GetLine("Filepath > ", tmpBuffer, 256);
tmpLong3 = GetLong("Song index > ");
if (bufferPtr)
{
free(bufferPtr);
bufferPtr = NULL;
}
filePtr = fopen(tmpBuffer, "rb");
if (filePtr != NULL)
{
// Find the length of the file
fseek(filePtr, 0, SEEK_END);
tmpLong1 = ftell(filePtr);
// Return to the beginning
fseek(filePtr, 0, SEEK_SET);
// Now blast everything to a malloc'd buffer
bufferPtr = malloc((size_t) tmpLong1);
tmpLong2 = fread(bufferPtr, sizeof(char), tmpLong1, filePtr);
if (tmpLong2 != tmpLong1)
{
/// Yikes, we have an anomaly -- could check ferror...
printf("ERROR: File read error -- not BAE related...\n");
}
else
{
err = BAESong_LoadRmfFromMemory(gSongs[slot],
bufferPtr,
(unsigned long)tmpLong2,
(short)tmpLong3,
TRUE);
}
fclose(filePtr);
}
else
{
printf("ERROR: Couldn't find file to open into memory -- not BAE related...\n");
}
}
break;
case FUNC_LOAD_RMF_FROM_FILE:
// BAESong_LoadRmfFromFile(BAESong song, BAEPathName filePath, short int songIndex, BAE_BOOL ignoreBadInstruments);
{
GetLine("Filepath > ", tmpBuffer, 256);
tmpLong1 = GetLong("Song index > ");
tmpBool = GetBool("Ignore bad instruments? (y/n) > ");
err = BAESong_LoadRmfFromFile(gSongs[slot], (BAEPathName)tmpBuffer, (short)tmpLong1, tmpBool);
}
break;
case FUNC_PREROLL:
// BAESong_Preroll(BAESong song);
{
err = BAESong_Preroll(gSongs[slot]);
}
break;
case FUNC_START:
// BAESong_Start(BAESong song, short int priority);
{
tmpLong1 = GetLong("Priority > ");
err = BAESong_Start(gSongs[slot], (short)tmpLong1);
}
break;
case FUNC_STOP:
// BAESong_Stop(BAESong song, BAE_BOOL startFade);
{
tmpBool = GetBool("Start fade? (y/n) > ");
err = BAESong_Stop(gSongs[slot], tmpBool);
}
break;
case FUNC_PAUSE:
// BAESong_Pause(BAESong song);
{
err = BAESong_Pause(gSongs[slot]);
}
break;
case FUNC_RESUME:
// BAESong_Resume(BAESong song);
{
err = BAESong_Resume(gSongs[slot]);
}
break;
case FUNC_IS_PAUSED:
// BAESong_IsPaused(BAESong song, BAE_BOOL *outIsPaused);
{
err = BAESong_IsPaused(gSongs[slot], &tmpBool);
if (!err) printf(": IsPaused = %d\n", (int)tmpBool);
}
break;
case FUNC_FADE:
// BAESong_Fade(BAESong song, BAE_FIXED sourceVolume, BAE_FIXED destVolume, BAE_FIXED timeInMiliseconds);
{
tmpDouble1 = GetDouble("sourceVolume (1.0 norm) > ");
tmpDouble2 = GetDouble("destVolume (1.0 norm) > ");
tmpDouble3 = GetDouble("time (msec) > ");
err = BAESong_Fade(gSongs[slot], FLOAT_TO_FIXED(tmpDouble1), FLOAT_TO_FIXED(tmpDouble2), FLOAT_TO_FIXED(tmpDouble3));
}
break;
case FUNC_IS_DONE:
// BAESong_IsDone(BAESong song, BAE_BOOL *outIsDone);
{
err = BAESong_IsDone(gSongs[slot], &tmpBool);
if (!err) printf(": IsDone = %d\n", (int)tmpBool);
}
break;
case FUNC_ARE_MIDI_EVENTS_PENDING:
// BAESong_AreMidiEventsPending(BAESong song, BAE_BOOL *outPending);
{
err = BAESong_AreMidiEventsPending(gSongs[slot], &tmpBool);
if (!err) printf(": Events Pending = %d\n", (int)tmpBool);
}
break;
case FUNC_SET_LOOPS:
// BAESong_SetLoops(BAESong song, short numLoops);
{
tmpLong1 = GetLong("Number of loops (0 = no repeats)> ");
err = BAESong_SetLoops(gSongs[slot], (short)tmpLong1);
}
break;
case FUNC_GET_LOOPS:
// BAESong_GetLoops(BAESong song, short int *outNumLoops);
{
err = BAESong_GetLoops(gSongs[slot], (short *)&tmpLong1);
if (!err) printf(": maxLoopCount = %d\n", (short)tmpLong1);
}
break;
case FUNC_SET_LOOP_FLAG:
// BAESong_SetLoopFlag(BAESong song, BAE_BOOL loop);
{
// tmpBool = GetBool("loop? (y/n) > ");
// err = BAESong_SetLoopFlag(gSongs[slot], tmpBool);
// NO LONGER SUPPORTED!
err = BAE_GENERAL_BAD;
}
break;
case FUNC_GET_LOOP_FLAG:
// BAESong_GetLoopFlag(BAESong song, BAE_BOOL *outLoop);
{
// err = BAESong_GetLoopFlag(gSongs[slot], &tmpBool);
// if (!err) printf(": Loop flag = %d\n", (int)tmpBool);
// NO LONGER SUPPORTED!
err = BAE_GENERAL_BAD;
}
break;
case FUNC_SET_MICROSECOND_POSITION:
// BAESong_SetMicrosecondPosition(BAESong song, unsigned long ticks);
{
tmpLong1 = GetLong("Ticks > ");
err = BAESong_SetMicrosecondPosition(gSongs[slot], (unsigned long)tmpLong1);
}
break;
case FUNC_GET_MICROSECOND_POSITION:
// BAESong_GetMicrosecondPosition(BAESong song, unsigned long *outTicks);
{
err = BAESong_GetMicrosecondPosition(gSongs[slot], (unsigned long *)&tmpLong1);
if (!err) printf(": Microsecond position = %ul\n", (unsigned long)tmpLong1);
}
break;
case FUNC_GET_MICROSECOND_LENGTH:
// BAESong_GetMicrosecondLength(BAESong song, unsigned long *outLength);
{
err = BAESong_GetMicrosecondLength(gSongs[slot], (unsigned long *)&tmpLong1);
if (!err) printf(": Length = %ul\n", tmpLong1);
}
break;
case FUNC_SET_MASTER_TEMPO:
// BAESong_SetMasterTempo(BAESong song, BAE_UNSIGNED_FIXED tempoFactor);
{
tmpDouble1 = GetDouble("Tempo factor (1.0 norm) > ");
err = BAESong_SetMasterTempo(gSongs[slot], FLOAT_TO_UNSIGNED_FIXED(tmpDouble1));
}
break;
case FUNC_GET_MASTER_TEMPO:
// BAESong_GetMasterTempo(BAESong song, BAE_UNSIGNED_FIXED *outTempoFactor);
{
err = BAESong_GetMasterTempo(gSongs[slot], &tmpUFixed);
if (!err) printf(": Tempo factor = %g\n", UNSIGNED_FIXED_TO_FLOAT(tmpUFixed));
}
break;
case FUNC_MUTE_TRACK:
// BAESong_MuteTrack(BAESong song, unsigned short int track);
{
tmpLong1 = GetLong("Track > ");
err = BAESong_MuteTrack(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_UNMUTE_TRACK:
// BAESong_UnmuteTrack(BAESong song, unsigned short int track);
{
tmpLong1 = GetLong("Track > ");
err = BAESong_UnmuteTrack(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_GET_TRACK_MUTE_STATUS:
// BAESong_GetTrackMuteStatus(BAESong song, BAE_BOOL *outTracks);
{
BAE_BOOL result[65];
int i,j;
err = BAESong_GetTrackMuteStatus(gSongs[slot], result);
if (!err)
{
for (j=0; j<4; j++)
{
printf("track: %d0%d1%d2%d3%d4%d5%d6%d7%d8%d9%dA%dB%dC%dD%dE%dF\n",j,j,j,j,j,j,j,j,j,j,j,j,j,j,j,j);
printf("mute status: ");
for (i=0; i<16; i++)
{
printf(" %d", (int)result[j*16 + i]);
}
printf("\n\n");
}
}
}
break;
case FUNC_SOLO_TRACK:
// BAESong_SoloTrack(BAESong song, unsigned short int track);
{
tmpLong1 = GetLong("Track > ");
err = BAESong_SoloTrack(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_UNSOLO_TRACK:
// BAESong_UnSoloTrack(BAESong song, unsigned short int track);
{
tmpLong1 = GetLong("Track > ");
err = BAESong_UnSoloTrack(gSongs[slot], (unsigned short)tmpLong1);
}
break;
case FUNC_GET_SOLO_TRACK_STATUS:
// BAESong_GetSoloTrackStatus(BAESong song, BAE_BOOL *outTracks);
{
BAE_BOOL result[65];
int i,j;
err = BAESong_GetSoloTrackStatus(gSongs[slot], result);
if (!err)
{
for (j=0; j<4; j++)
{
printf("track: %d0%d1%d2%d3%d4%d5%d6%d7%d8%d9%dA%dB%dC%dD%dE%dF\n",j,j,j,j,j,j,j,j,j,j,j,j,j,j,j,j);
printf("solo status: ");
for (i=0; i<16; i++)
{
printf(" %d", (int)result[j*16 + i]);
}
printf("\n\n");
}
}
}
break;
default:
break;
}
if (err)
{
printf("\a! Error code: %s (%d)\n", BAEResultToStr(err), (int)err);
}
else
{
printf("OK.\n");
}
}
static void PV_TestLoadSong(void)
{
BAESong song0, song1, song2, song3;
BAEResult err;
song0 = NULL;
err = BAESong_LoadMidiFromFile(song0, "", TRUE);
if (err != BAE_NULL_OBJECT)
{
FailedTest("BAESong_LoadMidiFromFile() didn't return BAE_NULL_OBJECT");
}
err = BAESong_LoadRmfFromFile(song0, "", 1, TRUE);
if (err != BAE_NULL_OBJECT)
{
FailedTest("BAESong_LoadRmfFromFile() didn't return BAE_NULL_OBJECT");
}
// err = BAESong_LoadMidiFromMemory(song0, "", TRUE);
// if (err != BAE_NULL_OBJECT)
// {
// FailedTest("BAESong_LoadMidiFromMemory() didn't return BAE_NULL_OBJECT");
// }
// err = BAESong_LoadRmfFromMemory(song0, "", 1, TRUE);
// if (err != BAE_NULL_OBJECT)
// {
// FailedTest("BAESong_LoadRmfFromMemory() didn't return BAE_NULL_OBJECT");
// }
err = BAESong_LoadGroovoid(song0, "", TRUE);
if (err != BAE_NULL_OBJECT)
{
FailedTest("BAESong_LoadGroovoid() didn't return BAE_NULL_OBJECT");
}
song0 = BAESong_New(gMixer);
song1 = BAESong_New(gMixer);
song2 = BAESong_New(gMixer);
song3 = BAESong_New(gMixer);
err = BAESong_LoadMidiFromFile(song0, "testMidi1.mid", TRUE);
if (err == BAE_NO_ERROR)
{
err = BAESong_Start(song0, 0);
}
else
{
}
err = BAESong_LoadMidiFromFile(song1, "testMidi2.mid", TRUE);
if (err == BAE_NO_ERROR)
{
err = BAESong_Start(song1, 0);
}
else
{
}
err = BAESong_LoadMidiFromFile(song2, "fakefile.mid", TRUE);
if (err == BAE_NO_ERROR)
{
}
else
{
}
err = BAESong_LoadRmfFromFile(song3, "testRmf1.rmf", 1, TRUE);
if (err == BAE_NO_ERROR)
{
}
else
{
}
}
// DoScript()
// -----------------------------------------------------
//
//
static void PV_DoScript(int subMenu)
{
BAEResult err;
err = BAE_NO_ERROR;
switch (subMenu)
{
case SCRIPT_ALL: // "Do all tests"
// PV_TestAll();
break;
case SCRIPT_NEW: // "Test New/Delete"
// PV_TestConstructor();
break;
case SCRIPT_LOAD_SONG: // "Test Loading Songs"
// PV_TestLoadSong();
break;
case SCRIPT_KEYBOARD:
PV_TestKeyboard();
break;
case SCRIPT_NOTE_ON:
// PV_TestNoteOn();
break;
case SCRIPT_SHOW_LOADED_INSTS:
{
long slot;
BAE_BOOL isLoaded;
int i;
slot = GetLong("Slot: ");
if (gSongs[slot])
{
printf(" Loaded instruments: ");
// These numbers are hardcoded into the engine,
// and currently not exposed in MiniBAE.h,
//
// Max number of instruments = 256
// Max number of banks = 3
// Max number of instruments = 256*3 = 768
for (i=0; i<768; i++)
{
err = BAESong_IsInstrumentLoaded(gSongs[slot], i, &isLoaded);
if (err)
{
printf("err = %d\n", (long)err);
}
else
{
if (isLoaded) printf("%d, ", i);
}
}
printf("\n");
}
else
{
printf("No song in slot %d\n", slot);
}
}
break;
case SCRIPT_LOAD_DEFAULT_MIDI:
case SCRIPT_LOAD_DEFAULT_MIDI1:
case SCRIPT_LOAD_DEFAULT_MIDI2:
case SCRIPT_LOAD_DEFAULT_MIDI3:
{
if (gSongs[0] == NULL)
{
gSongs[0] = BAESong_New(gMixer);
}
switch(subMenu)
{
case SCRIPT_LOAD_DEFAULT_MIDI:
err = BAESong_LoadMidiFromFile(gSongs[0], DEFAULT_MIDI_FILE, TRUE);
break;
case SCRIPT_LOAD_DEFAULT_MIDI1:
err = BAESong_LoadMidiFromFile(gSongs[0], DEFAULT_MIDI_FILE1, TRUE);
break;
case SCRIPT_LOAD_DEFAULT_MIDI2:
err = BAESong_LoadMidiFromFile(gSongs[0], DEFAULT_MIDI_FILE2, TRUE);
break;
case SCRIPT_LOAD_DEFAULT_MIDI3:
err = BAESong_LoadMidiFromFile(gSongs[0], DEFAULT_MIDI_FILE3, TRUE);
break;
}
}
break;
case SCRIPT_LOAD_DEFAULT_MPEG_RMF:
{
if (gSongs[0] == NULL)
{
gSongs[0] = BAESong_New(gMixer);
}
err = BAESong_LoadRmfFromFile(gSongs[0], DEFAULT_RMF_MPEG_FILE, 0, TRUE);
}
break;
case SCRIPT_LOAD_DEFAULT_RMF:
{
if (gSongs[0] == NULL)
{
gSongs[0] = BAESong_New(gMixer);
}
err = BAESong_LoadRmfFromFile(gSongs[0], DEFAULT_RMF_FILE, 0, TRUE);
}
break;
case SCRIPT_LOAD_DEFAULT_GROOVOID:
{
if (gSongs[0] == NULL)
{
gSongs[0] = BAESong_New(gMixer);
}
err = BAESong_LoadGroovoid(gSongs[0], DEFAULT_GROOVOID, TRUE);
}
break;
default:
break;
}
if (err)
{
printf("\a! Error code: %s (%d)\n", BAEResultToStr(err), (int)err);
}
else
{
printf("OK.\n");
}
}