562 lines
12 KiB
C
Executable File
562 lines
12 KiB
C
Executable File
/*
|
||
Copyright (C) 1994-1995 Apogee Software, Ltd.
|
||
|
||
This program is free software; you can redistribute it and/or
|
||
modify it under the terms of the GNU General Public License
|
||
as published by the Free Software Foundation; either version 2
|
||
of the License, or (at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||
|
||
See the GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program; if not, write to the Free Software
|
||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||
|
||
*/
|
||
/*********** ***********************************************************
|
||
file: GUSMIDI.C
|
||
|
||
author: James R. Dose
|
||
date: March 23, 1994
|
||
|
||
General MIDI playback functions for the Gravis Ultrasound
|
||
|
||
(c) Copyright 1994 James R. Dose. All Rights Reserved.
|
||
**********************************************************************/
|
||
|
||
// Module MUST be compiled with structure allignment set to a maximum
|
||
// of 1 byte ( zp1 ).
|
||
|
||
#include <conio.h>
|
||
#include <dos.h>
|
||
#include <stdio.h>
|
||
#include <io.h>
|
||
#include <fcntl.h>
|
||
#include <string.h>
|
||
#include <stdlib.h>
|
||
#include "usrhooks.h"
|
||
#include "interrup.h"
|
||
#include "newgf1.h"
|
||
#include "gusmidi.h"
|
||
|
||
#define TRUE ( 1 == 1 )
|
||
#define FALSE ( !TRUE )
|
||
|
||
// size of DMA buffer for patch loading
|
||
#define DMABUFFSIZE 2048U
|
||
|
||
#define MAX_MEM_CONFIG 3
|
||
|
||
// size of patch array (128 perc, 128 melodic)
|
||
#define NUM_PATCHES 256
|
||
|
||
// size of largest patch name
|
||
#define BIGGEST_NAME 9
|
||
|
||
#define UNUSED_PATCH -1
|
||
|
||
static struct patch Patch[ NUM_PATCHES ];
|
||
static unsigned char *PatchWaves[ NUM_PATCHES ];
|
||
|
||
static int PatchMap[ NUM_PATCHES ][ MAX_MEM_CONFIG + 1 ];
|
||
static char ProgramName[ NUM_PATCHES ][ BIGGEST_NAME ];
|
||
static char PatchLoaded[ NUM_PATCHES ];
|
||
|
||
static char ConfigFileName[] = "ULTRAMID.INI";
|
||
static char ConfigDirectory[ 80 ] = { '\0' };
|
||
|
||
// The name of the configuration directory
|
||
static char InstrumentDirectory[ 80 ];
|
||
|
||
extern struct gf1_dma_buff GUS_HoldBuffer;
|
||
|
||
extern unsigned long GUS_TotalMemory;
|
||
extern int GUS_MemConfig;
|
||
|
||
static int GUSMIDI_Volume = 255;
|
||
|
||
extern int GUS_AuxError;
|
||
extern int GUS_ErrorCode;
|
||
|
||
int GUSMIDI_Installed = FALSE;
|
||
|
||
#define GUS_SetErrorCode( status ) \
|
||
GUS_ErrorCode = ( status );
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUS_GetPatchMap
|
||
|
||
Reads the patch map from disk.
|
||
---------------------------------------------------------------------*/
|
||
|
||
int GUS_GetPatchMap
|
||
(
|
||
char *name
|
||
)
|
||
|
||
{
|
||
char text[ 80 ];
|
||
char *ud;
|
||
int index;
|
||
int ignore;
|
||
FILE *fp;
|
||
|
||
for( index = 0; index < NUM_PATCHES; index++ )
|
||
{
|
||
PatchMap[ index ][ 0 ] = UNUSED_PATCH;
|
||
PatchMap[ index ][ 1 ] = UNUSED_PATCH;
|
||
PatchMap[ index ][ 2 ] = UNUSED_PATCH;
|
||
PatchMap[ index ][ 3 ] = UNUSED_PATCH;
|
||
ProgramName[ index ][ 0 ] = 0;
|
||
}
|
||
|
||
ud = getenv( "ULTRADIR" );
|
||
if ( ud == NULL )
|
||
{
|
||
GUS_SetErrorCode( GUS_ULTRADIRNotSet );
|
||
return( GUS_Error );
|
||
}
|
||
|
||
strcpy( InstrumentDirectory, ud );
|
||
strcat( InstrumentDirectory, "\\midi\\" );
|
||
strcpy( ConfigDirectory, ud );
|
||
strcat( ConfigDirectory, "\\midi\\" );
|
||
strcpy( text, name );
|
||
|
||
fp = fopen( text, "r" );
|
||
if ( fp == NULL )
|
||
{
|
||
strcpy( text, InstrumentDirectory );
|
||
strcat( text, name );
|
||
|
||
fp = fopen( text, "r" );
|
||
if ( fp == NULL )
|
||
{
|
||
GUS_SetErrorCode( GUS_MissingConfig );
|
||
return( GUS_Error );
|
||
}
|
||
}
|
||
|
||
while( 1 )
|
||
{
|
||
if ( fgets( text, 80, fp ) == NULL )
|
||
{
|
||
break;
|
||
}
|
||
|
||
if ( text[ 0 ] == '#' )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if ( sscanf( text, "%d", &index ) != 1 )
|
||
{
|
||
continue;
|
||
}
|
||
|
||
sscanf( text, "%d, %d, %d, %d, %d, %s\n", &ignore,
|
||
&PatchMap[ index ][ 0 ],
|
||
&PatchMap[ index ][ 1 ],
|
||
&PatchMap[ index ][ 2 ],
|
||
&PatchMap[ index ][ 3 ],
|
||
ProgramName[ index ] );
|
||
}
|
||
|
||
fclose( fp );
|
||
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_UnloadPatch
|
||
|
||
Unloads a patch from the GUS's memory.
|
||
---------------------------------------------------------------------*/
|
||
|
||
int GUSMIDI_UnloadPatch
|
||
(
|
||
int prognum
|
||
)
|
||
|
||
{
|
||
int prog;
|
||
unsigned flags;
|
||
|
||
prog = PatchMap[ prognum ][ GUS_MemConfig ];
|
||
|
||
if ( PatchLoaded[ prog ] )
|
||
{
|
||
flags = DisableInterrupts();
|
||
|
||
gf1_unload_patch( &Patch[ prog ] );
|
||
if ( PatchWaves[ prog ] != NULL )
|
||
{
|
||
USRHOOKS_FreeMem( PatchWaves[ prog ] );
|
||
PatchWaves[ prog ] = NULL;
|
||
}
|
||
|
||
// just in case sequence is still playing
|
||
Patch[ prog ].nlayers = 0;
|
||
PatchLoaded[ prog ] = FALSE;
|
||
|
||
RestoreInterrupts( flags );
|
||
}
|
||
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_LoadPatch
|
||
|
||
Loads a patch into the GUS's memory.
|
||
---------------------------------------------------------------------*/
|
||
|
||
int GUSMIDI_LoadPatch
|
||
(
|
||
int prognum
|
||
)
|
||
|
||
{
|
||
int prog;
|
||
char text[ 80 ];
|
||
int ret;
|
||
unsigned char *wave_buff;
|
||
struct patchinfo patchi;
|
||
int status;
|
||
|
||
prog = PatchMap[ prognum ][ GUS_MemConfig ];
|
||
|
||
if ( ( PatchLoaded[ prog ] ) || ( prog == UNUSED_PATCH ) )
|
||
{
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
if ( !ProgramName[ prog ][ 0 ] )
|
||
{
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
strcpy( text, InstrumentDirectory );
|
||
strcat( text, ProgramName[ prog ] );
|
||
strcat( text, ".pat" );
|
||
|
||
ret = gf1_get_patch_info( text, &patchi );
|
||
if ( ret != OK )
|
||
{
|
||
GUS_AuxError = ret;
|
||
GUS_SetErrorCode( GUS_GF1Error );
|
||
return( GUS_Error );
|
||
}
|
||
|
||
status = USRHOOKS_GetMem( &wave_buff, patchi.header.wave_forms *
|
||
sizeof( struct wave_struct ) );
|
||
if ( status != USRHOOKS_Ok )
|
||
{
|
||
GUS_SetErrorCode( GUS_OutOfMemory );
|
||
return( GUS_Error );
|
||
}
|
||
|
||
ret = gf1_load_patch( text, &patchi, &Patch[ prog ], &GUS_HoldBuffer,
|
||
DMABUFFSIZE, ( unsigned char * )wave_buff, PATCH_LOAD_8_BIT );
|
||
|
||
if ( ret != OK )
|
||
{
|
||
USRHOOKS_FreeMem( wave_buff );
|
||
GUS_AuxError = ret;
|
||
GUS_SetErrorCode( GUS_GF1Error );
|
||
return( GUS_Error );
|
||
}
|
||
|
||
PatchWaves[ prog ] = wave_buff;
|
||
PatchLoaded[ prog ] = TRUE;
|
||
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_ProgramChange
|
||
|
||
Selects the instrument to use on the specified MIDI channel.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_ProgramChange
|
||
(
|
||
int channel,
|
||
int prognum
|
||
)
|
||
|
||
{
|
||
int prog;
|
||
|
||
prog = PatchMap[ prognum ][ GUS_MemConfig ];
|
||
|
||
if ( PatchLoaded[ prog ] )
|
||
{
|
||
gf1_midi_change_program( &Patch[ prog ], channel );
|
||
}
|
||
else
|
||
{
|
||
gf1_midi_change_program( NULL, channel );
|
||
}
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_NoteOn
|
||
|
||
Plays a note on the specified channel.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_NoteOn
|
||
(
|
||
int chan,
|
||
int note,
|
||
int velocity
|
||
)
|
||
|
||
{
|
||
int prog;
|
||
|
||
if ( chan == 9 )
|
||
{
|
||
prog = PatchMap[ note + 128 ][ GUS_MemConfig ];
|
||
|
||
if ( PatchLoaded[ prog ] )
|
||
{
|
||
gf1_midi_note_on( &Patch[ note + 128 ], 1,
|
||
note, velocity, 9 );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
gf1_midi_note_on( 0L, 1, note, velocity, chan );
|
||
}
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_NoteOff
|
||
|
||
Turns off a note on the specified channel.
|
||
---------------------------------------------------------------------*/
|
||
#pragma warn -par
|
||
void GUSMIDI_NoteOff
|
||
(
|
||
int chan,
|
||
int note,
|
||
int velocity
|
||
)
|
||
|
||
{
|
||
gf1_midi_note_off( note, chan );
|
||
}
|
||
#pragma warn .par
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_ControlChange
|
||
|
||
Sets the value of a controller on the specified channel.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_ControlChange
|
||
(
|
||
int channel,
|
||
int number,
|
||
int value
|
||
)
|
||
|
||
{
|
||
gf1_midi_parameter( channel, number, value );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_PitchBend
|
||
|
||
Sets the pitch bend on the specified MIDI channel.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_PitchBend
|
||
(
|
||
int channel,
|
||
int lsb,
|
||
int msb
|
||
)
|
||
|
||
{
|
||
gf1_midi_pitch_bend( channel, lsb, msb );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_ReleasePatches
|
||
|
||
Removes all the instruments from the GUS's memory.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_ReleasePatches
|
||
(
|
||
void
|
||
)
|
||
|
||
{
|
||
int i;
|
||
|
||
for( i = 0; i < 256; i++ )
|
||
{
|
||
GUSMIDI_UnloadPatch( i );
|
||
}
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_SetVolume
|
||
|
||
Sets the total music volume.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_SetVolume
|
||
(
|
||
int volume
|
||
)
|
||
|
||
{
|
||
// Set the minimum to 2 because 0 has a tremolo problem
|
||
volume = max( 2, volume );
|
||
volume = min( volume, 255 );
|
||
|
||
GUSMIDI_Volume = volume;
|
||
|
||
// range = 0 to 127
|
||
gf1_midi_synth_volume( 0, volume >> 1 );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_GetVolume
|
||
|
||
Returns the total music volume.
|
||
---------------------------------------------------------------------*/
|
||
|
||
int GUSMIDI_GetVolume
|
||
(
|
||
void
|
||
)
|
||
|
||
{
|
||
return( GUSMIDI_Volume );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_Init
|
||
|
||
Initializes the Gravis Ultrasound for music playback.
|
||
---------------------------------------------------------------------*/
|
||
|
||
int GUSMIDI_Init
|
||
(
|
||
void
|
||
)
|
||
|
||
{
|
||
int ret;
|
||
int i;
|
||
int startmem;
|
||
// unsigned long mem;
|
||
extern int GUSWAVE_Installed;
|
||
|
||
if ( GUSMIDI_Installed )
|
||
{
|
||
GUSMIDI_Shutdown();
|
||
}
|
||
|
||
ret = GUS_Init();
|
||
if ( ret != GUS_Ok )
|
||
{
|
||
return( ret );
|
||
}
|
||
|
||
if ( GUS_MemConfig < 0 )
|
||
{
|
||
GUS_MemConfig = 0;
|
||
}
|
||
|
||
if ( GUS_MemConfig > MAX_MEM_CONFIG )
|
||
{
|
||
GUS_MemConfig = MAX_MEM_CONFIG;
|
||
}
|
||
|
||
for( i = 0; i < NUM_PATCHES; i++ )
|
||
{
|
||
ProgramName[ i ][ 0 ] = '\0';
|
||
PatchWaves[ i ] = NULL;
|
||
PatchLoaded[ i ] = FALSE;
|
||
}
|
||
|
||
GUSMIDI_SetVolume( 255 );
|
||
|
||
GUSMIDI_Installed = TRUE;
|
||
|
||
ret = GUS_GetPatchMap( ConfigFileName );
|
||
if ( ret != GUS_Ok )
|
||
{
|
||
GUSMIDI_Shutdown();
|
||
return( ret );
|
||
}
|
||
|
||
// if ( !GUSWAVE_Installed )
|
||
// {
|
||
// mem = gf1_malloc( 8192 );
|
||
// }
|
||
|
||
startmem = gf1_mem_avail();
|
||
for( i = 0; i < NUM_PATCHES; i++ )
|
||
{
|
||
ret = GUSMIDI_LoadPatch( i );
|
||
if ( ret != GUS_Ok )
|
||
{
|
||
}
|
||
// if ( ret != GUS_Ok )
|
||
// {
|
||
// return( ret );
|
||
// }
|
||
}
|
||
|
||
// if ( !GUSWAVE_Installed )
|
||
// {
|
||
// gf1_free( mem );
|
||
// }
|
||
|
||
GUSMIDI_Installed = TRUE;
|
||
|
||
return( GUS_Ok );
|
||
}
|
||
|
||
|
||
/*---------------------------------------------------------------------
|
||
Function: GUSMIDI_Shutdown
|
||
|
||
Ends use of the Gravis Ultrasound for music playback.
|
||
---------------------------------------------------------------------*/
|
||
|
||
void GUSMIDI_Shutdown
|
||
(
|
||
void
|
||
)
|
||
|
||
{
|
||
GUSMIDI_ReleasePatches();
|
||
GUS_Shutdown();
|
||
GUSMIDI_Installed = FALSE;
|
||
}
|