/*
PLAY.C
29-jun-88, Marc Savary, Ad Lib Inc.
Demo file to play the AdLib MIDI music file ( *.MUS) with the *.SND
timbre bank file.
This simple driver use the PC's timer-0 for timing. (see TIMER.ASM )
See "convert.c" for *.MUS file structure.
This file and the file BANK.C (timbre bank manager) MUST BE compiled
WITHOUT stack overflow check. (-v option of Lattice C Compiler,
-Gs for Microsoft)
If compiling with Lattice, 'LATTICE' must be defined for this file
and BANK.C.
With Microsoft, use the following ('MICROSOFT' must be defined for
this file and BANK.C):
masm timer.asm
cl -DMICROSOFT -AS -J -Zi -Zp1 -Ox -Gs -c play.c bank.c adlib.c
link play.obj adlib.obj bank.obj timer.obj
*/
#include <stdio.h>
#include <fcntl.h>
#include "convert.h"
#include "bank.h"
#ifdef MICROSOFT
#define UNSIGNED_CHAR unsigned char
#endif
#ifdef LATTICE
#define UNSIGNED_CHAR char
#endif
BankPtr bank; /* pointer to instrument bank */
char * musPtr; /* pointer to first data byte of melody */
struct MusHeader * headPtr; /* pointer to header of .MUS file */
char musRunning; /* != 0 if music is playing */
UNSIGNED_CHAR status; /* running status byte */
char volume[ NR_VOICES]; /* actual volume of all voices */
long tickCount; /* time counter, for information only */
unsigned delay; /* length of last delay */
#ifdef LATTICE
extern char * getmem();
extern int allmem();
extern int rlsmem();
#endif
#ifdef MICROSOFT
#include <malloc.h>
#include <string.h>
#define rlsmem(x,y) free(x)
#define getmem(x) malloc(x)
#define setmem(x,y,z) memset(x,z,y)
#define movmem(x,y,z) memmove(y,x,z)
#define max(x,y) ((x > y) ? x:y)
#endif
/*
Simple demonstration.
Syntax: play <musfile.mus> <bankfile.snd>
*/
main( argc, argv)
int argc;
char * argv[];
{
struct MusHeader mH;
int meloFile;
char * music;
unsigned len;
BankPtr theBank;
if( argc < 3) {
fprintf( stderr, "\nUSE: play <musfile.mus> <bankfile.snd>");
exit( 1);
}
/* Perform some initialisations ... */
Init();
if( NULL == ( theBank = OpenBank( argv[ 2], 0))) {
fprintf( stderr, "\nUnable to open timbre bank file '%s'.", argv[ 2]);
Terminate();
exit( 1);
}
if( !LoadBank( theBank)) {
fprintf( stderr, "\nError while reading timbre bank.");
Terminate();
exit( 1);
}
meloFile = open( argv[ 1], O_RDONLY + O_RAW);
if( -1 == meloFile) {
fprintf( stderr, "\nUnable to open music file '%s'.", argv[ 1]);
Terminate();
exit( 1);
}
/* read the music file's header: */
read( meloFile, &mH, sizeof( struct MusHeader));
len = mH.dataSize;
music = (char *) getmem( (unsigned) len);
if( music == NULL) {
fprintf( stderr, "\nMemory allocation error.");
exit( 1);
}
/* load all the data in memory: */
read( meloFile, music, len);
/* Start playing: */
StartMelo( &mH, music, len, theBank);
/* wait until end.... */
WaitEndMelo();
/* uninstall the clock driver: */
Terminate();
rlsmem( music, len);
CloseBank( theBank);
} /* main() */
/*
Wait until the end of melody ( musRunning == 0)
*/
WaitEndMelo()
{
static unsigned measure = 0, beat = 0;
unsigned m, b, c, i;
/* cprintf( "\nPress ESC key to stop"); */
while( musRunning) {
if( kbhit()) {
c = getch();
if( c == 0x1b)
StopMelo();
}
#ifdef DEBUG
m = tickCount / (headPtr->beatMeasure * headPtr->tickBeat);
b = tickCount / headPtr->tickBeat;
if( m != measure) {
printf( "\nMeasure: %03d ", m);
measure = m;
}
if( b != beat) {
printf( "+ ");
beat = b;
}
#endif
}
} /* WaitEndMelo() */
/*
Initialize the driver.
*/
Init()
{
/* initalize the low-level sound-driver: */
if( !SoundColdInit( 0x388)) {
printf( "\nAdlib board not found!");
exit( 1);
}
/* allocate all the memory available:*/
#ifdef LATTICE
allmem();
#endif
/* install the clock driver: */
Clk_install();
}
/*
Uninstall the clock driver ...
*/
Terminate()
{
Clk_uninstall();
}
/*
Start playing a melody. Set some global pointers for the interrupt
routine. Set the tempo, sound mode & pitch bend range.
Reset volume of each voice. Start the clock driver with the first
delay ( >= 1)
*/
StartMelo( header, data, len, timBank)
struct MusHeader * header; /* pointer to header struc. of music file */
char * data; /* pointer to music data */
unsigned len; /* size of data */
BankPtr timBank; /* bank of timbres */
{
int i;
musPtr = data;
headPtr = header;
bank = timBank;
tickCount = 0;
for( i = 0; i < NR_VOICES; i++)
volume[ i] = 0;
SetMode( header->soundMode);
SetPitchRange( header->pitchBRange);
SetTempo( header->basicTempo, header->tickBeat);
StartTimeOut( 0);
delay = *musPtr++;
musRunning = 1;
/* NEVER START COUNT-DOWN WITH 0, since 0 means MAXIMUM delay!!! */
StartTimeOut( max( delay, 1));
} /* StartMelo() */
/*
Stop playing the melody. Send note-off to all voices and reset
the clock frequency to nominal ( 18.2 Hz).
*/
StopMelo()
{
int i;
musRunning = 0;
for( i = 0; i < NR_VOICES; i++)
NoteOff( i);
SetTempo( 0, 1);
} /* StopMelo() */
/*
Change the tempo.
Reload the timer-0 with the proper divider for generating
the appropriate frequency.
If tempo is zero, reprogram the counter for 18.2 Hz.
*/
SetTempo( tempo, tickBeat)
unsigned tempo; /* beats per minute */
unsigned tickBeat; /* ticks per beat */
{
long t1;
unsigned freq;
unsigned low, high, flags, count;
t1 = tickBeat * (long)tempo;
freq = t1 /60; /* interrupt rate needed */
if( !freq)
count = 0;
else {
/* make sure that frequency is >= 19 Hz, since counter min. output
frequency is 18.2 Hz: */
freq = freq < 19 ? 19 : freq;
/* compute counter divider: */
count = (1193180 /(long)freq);
}
/* and set the counter: */
SetClkRate( count);
} /* SetTempo() */
/*
Interrupt routine. Called by low-level clock driver when
the delay count has expired.
'musPtr' always points to an OVERFLOW BYTE or to the first byte AFTER
the timing byte.
When this routine is called, the active SS ( stack segment) is not
the original of the application, so take care.
This routine, and all others called by, must be compiled
without stack-overflow checking, since the SS has changed!!!
Return to caller the number of clock ticks to wait for before
the next call.
*/
unsigned TimeOut()
{
unsigned pitch, tempo, haut, vol;
UNSIGNED_CHAR newStatus;
int timbreDef[ TIMBRE_DEF_LEN], timbre;
int comm, id, integer, frac, voice = 1;
if( ! musRunning)
/* Music has not started or has been stopped, so wait the minimum delay ... */
return 1;
tickCount += delay;
do {
newStatus = *musPtr;
if( newStatus == OVERFLOW_BYTE) {
/* timing overflow ... */
musPtr++;
delay = OVERFLOW_BYTE;
break;
}
else if( newStatus == STOP_BYTE) {
StopMelo();
return 0; /* maximum delay ... */
}
else if( newStatus == SYSTEM_XOR_BYTE) {
/*
non-standard... this is a tempo multiplier:
data format: <F0> <7F> <00> <integer> <frac> <F7>
tempo = basicTempo * integerPart + basicTempo * fractionPart/128
*/
musPtr++;
id = *musPtr++;
comm = *musPtr++;
if( id != ADLIB_CTRL_BYTE || comm != TEMPO_CTRL_BYTE) {
/* unknown format ... skip all the XOR message */
musPtr -= 2;
while( *musPtr++ != EOX_BYTE)
;
}
else {
integer = *musPtr++;
frac = *musPtr++;
tempo = headPtr->basicTempo;
tempo = tempo * integer + (unsigned)(((long)tempo * frac) >> 7);
SetTempo( tempo, headPtr->tickBeat);
musPtr++; /* skip EOX_BYTE */
}
delay = *musPtr++;
}
else {
if( newStatus >= 0x80) {
musPtr++;
status = newStatus;
}
voice = (int) (status & 0x0f);
switch( status & 0xf0) {
case NOTE_ON_BYTE:
haut = *musPtr++;
vol = *musPtr++;
if( ! vol) {
NoteOff( voice);
}
else {
if( vol != volume[ voice]) {
SetVoiceVolume( voice, vol);
volume[ voice] = vol;
}
NoteOn( voice, haut);
}
break;
case NOTE_OFF_BYTE:
musPtr += 2;
NoteOff( voice);
break;
case AFTER_TOUCH_BYTE:
SetVoiceVolume( voice, *musPtr++);
break;
case PROG_CHANGE_BYTE:
timbre = *musPtr++;
if( GetTimbre( "", &timbre, timbreDef, bank)) {
SetVoiceTimbre( voice, timbreDef);
}
else
cprintf( "\nTimbre not found: %d", timbre);
break;
case PITCH_BEND_BYTE:
pitch = *musPtr++;
pitch += (unsigned)(*musPtr++) << 7;
SetVoicePitch( voice, pitch);
break;
case CONTROL_CHANGE_BYTE:
/* not implemented ... */
musPtr += 2;
break;
case CHANNEL_PRESSURE_BYTE:
/* not implemented ... */
musPtr++;
break;
default:
cprintf( "\nBad MIDI status byte: %d", status);
SkipToTiming();
break;
}
delay = *musPtr++;
}
} while( delay == 0);
if( delay == OVERFLOW_BYTE) {
delay = OVERFLOW;
if( *musPtr != OVERFLOW_BYTE)
delay += *musPtr++;
}
return delay;
}
/*
A bad status byte ( or unimplemented MIDI command) has been encontered.
Skip bytes until next timing byte followed by status byte.
*/
static SkipToTiming()
{
while( *musPtr < 0x80)
musPtr++;
if( *musPtr != OVERFLOW_BYTE)
musPtr--;
} /* SkipToTiming() */
