Path: utzoo!mnetor!uunet!husc6!rutgers!iuvax!pur-ee!j.cc.purdue.edu!ain
From: ain@j.cc.purdue.edu (Patrick White)
Newsgroups: comp.sources.amiga
Subject: midi library  (lib source)
Message-ID: <6772@j.cc.purdue.edu>
Date: 25 Mar 88 04:23:40 GMT
Organization: PUCC Land, USA
Lines: 498
Keywords: midi, library, docs
Approved: ain@j.cc.purdue.edu  (Pat White)

Program Name:	midi library  (lib source)
Submitted By:	Pete Yadlowsky <pmy@vivaldi.acc.virginia.edu>
Summary:	This is a midi library
Poster Boy:  Pat White  (ain@j.cc.purdue.edu)
Untested.

NOTES:
   Not much we could do to test this, so we didn't bother.
   I reshar'ed it to separate docs, etc.


-- Pat White   (co-moderator comp.sources/binaries.amiga)
UUCP: j.cc.purdue.edu!ain  BITNET: PATWHITE@PURCCVM   PHONE: (317) 743-8421
U.S.  Mail:  320 Brown St. apt. 406,    West Lafayette, IN 47906

========================================

#	This is a shell archive.
#	Remove everything above and including the cut line.
#	Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar:	Shell Archiver
#	Run the following text with /bin/sh to create:
#	Makefile
#	credst.asm
#	crerte.asm
#	cresrc.asm
#	deldst.asm
#	delrte.asm
#	delsrc.asm
#	finddst.asm
#	findsrc.asm
#	freemsg.asm
#	getmsg.asm
#	lockbase.asm
#	midilvo.asm
#	modrte.asm
#	msglen.asm
#	msgtype.asm
#	putmsg.asm
#	putstr.asm
#	rtedst.asm
#	rtepub.asm
#	rtesrc.asm
#	unlockba.asm
# This archive created: Sun Mar 20 16:45:19 1988
# By:	Patrick White (PUCC Land, USA)
echo shar: extracting Makefile '(381 characters)'
cat << \SHAR_EOF > Makefile
# midi.lib makefile

CFLAGS=-n +b
AFLAGS=

MIDI_LIB=\
 credst.o crerte.o cresrc.o deldst.o delrte.o delsrc.o finddst.o\
 findsrc.o freemsg.o getmsg.o lockbase.o modrte.o msglen.o msgtype.o\
 putmsg.o putstr.o rtedst.o rtepub.o rtesrc.o unlockba.o midilvo.o

all: midi.lib

midi.lib: $(MIDI_LIB)
	lb $@ $(MIDI_LIB)

#midilvo.asm: /lib/midibase.asm
#	 makelvo /lib/midibase midilvo

SHAR_EOF
if test 381 -ne "`wc -c Makefile`"
then
echo shar: error transmitting Makefile '(should have been 381 characters)'
fi
echo shar: extracting credst.asm '(217 characters)'
cat << \SHAR_EOF > credst.asm
	public	_MidiBase,_LVOCreateMDest

; struct MDest *CreateMDest (name,image)
; char *name;
; struct Image *image;

	public	_CreateMDest
_CreateMDest
	movem.l  4(sp),a0-a1
	move.l	_MidiBase,a6
	jmp	_LVOCreateMDest(a6)

SHAR_EOF
if test 217 -ne "`wc -c credst.asm`"
then
echo shar: error transmitting credst.asm '(should have been 217 characters)'
fi
echo shar: extracting crerte.asm '(316 characters)'
cat << \SHAR_EOF > crerte.asm
	public	_MidiBase,_LVOCreateMRoute

; struct Route *CreateMRoute (source,dest,routeinfo)
; Struct MSource *source;
; Struct MDest *dest;
; Struct MRouteInfo *routeinfo;

	public	_CreateMRoute
_CreateMRoute
	movem.l a2,-(sp)
	movem.l 8(sp),a0-a2
	move.l	_MidiBase,a6
	jsr	_LVOCreateMRoute(a6)
	movem.l (sp)+,a2
	rts

SHAR_EOF
if test 316 -ne "`wc -c crerte.asm`"
then
echo shar: error transmitting crerte.asm '(should have been 316 characters)'
fi
echo shar: extracting cresrc.asm '(229 characters)'
cat << \SHAR_EOF > cresrc.asm
	public	_MidiBase,_LVOCreateMSource

; struct MSource *CreateMSource (name,image)
; char *name;
; struct Image *image;

	public	_CreateMSource
_CreateMSource
	movem.l  4(sp),a0-a1
	move.l	_MidiBase,a6
	jmp	_LVOCreateMSource(a6)

SHAR_EOF
if test 229 -ne "`wc -c cresrc.asm`"
then
echo shar: error transmitting cresrc.asm '(should have been 229 characters)'
fi
echo shar: extracting deldst.asm '(177 characters)'
cat << \SHAR_EOF > deldst.asm
	public	_MidiBase,_LVODeleteMDest

; DeleteMDest (dest)
; struct MDest *dest;

	public	_DeleteMDest
_DeleteMDest
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVODeleteMDest(a6)

SHAR_EOF
if test 177 -ne "`wc -c deldst.asm`"
then
echo shar: error transmitting deldst.asm '(should have been 177 characters)'
fi
echo shar: extracting delrte.asm '(185 characters)'
cat << \SHAR_EOF > delrte.asm
	public	_MidiBase,_LVODeleteMRoute

; DeleteMRoute (route)
; struct MRoute *route;

	public	_DeleteMRoute
_DeleteMRoute
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVODeleteMRoute(a6)

SHAR_EOF
if test 185 -ne "`wc -c delrte.asm`"
then
echo shar: error transmitting delrte.asm '(should have been 185 characters)'
fi
echo shar: extracting delsrc.asm '(193 characters)'
cat << \SHAR_EOF > delsrc.asm
	public	_MidiBase,_LVODeleteMSource

; DeleteMSource (source)
; struct MSource *source;

	public	_DeleteMSource
_DeleteMSource
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVODeleteMSource(a6)

SHAR_EOF
if test 193 -ne "`wc -c delsrc.asm`"
then
echo shar: error transmitting delsrc.asm '(should have been 193 characters)'
fi
echo shar: extracting finddst.asm '(173 characters)'
cat << \SHAR_EOF > finddst.asm
	public	_MidiBase,_LVOFindMDest

; struct MDest *FindMDest (name)
; char *name;

	public	_FindMDest
_FindMDest
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOFindMDest(a6)

SHAR_EOF
if test 173 -ne "`wc -c finddst.asm`"
then
echo shar: error transmitting finddst.asm '(should have been 173 characters)'
fi
echo shar: extracting findsrc.asm '(185 characters)'
cat << \SHAR_EOF > findsrc.asm
	public	_MidiBase,_LVOFindMSource

; struct MSource *FindMSource (name)
; char *name;

	public	_FindMSource
_FindMSource
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOFindMSource(a6)

SHAR_EOF
if test 185 -ne "`wc -c findsrc.asm`"
then
echo shar: error transmitting findsrc.asm '(should have been 185 characters)'
fi
echo shar: extracting freemsg.asm '(169 characters)'
cat << \SHAR_EOF > freemsg.asm
	public	_MidiBase,_LVOFreeMidiMsg

; FreeMidiMsg (msg)
; UBYTE *msg;

	public	_FreeMidiMsg
_FreeMidiMsg
	movem.l 4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOFreeMidiMsg(a6)

SHAR_EOF
if test 169 -ne "`wc -c freemsg.asm`"
then
echo shar: error transmitting freemsg.asm '(should have been 169 characters)'
fi
echo shar: extracting getmsg.asm '(179 characters)'
cat << \SHAR_EOF > getmsg.asm
	public	_MidiBase,_LVOGetMidiMsg

; UBYTE *GetMidiMsg (dest)
; struct MDest *dest

	public	_GetMidiMsg
_GetMidiMsg
	movem.l 4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOGetMidiMsg(a6)

SHAR_EOF
if test 179 -ne "`wc -c getmsg.asm`"
then
echo shar: error transmitting getmsg.asm '(should have been 179 characters)'
fi
echo shar: extracting lockbase.asm '(138 characters)'
cat << \SHAR_EOF > lockbase.asm
	public	_MidiBase,_LVOLockMidiBase

; LockMidiBase()

	public	_LockMidiBase
_LockMidiBase
	move.l	_MidiBase,a6
	jmp	_LVOLockMidiBase(a6)

SHAR_EOF
if test 138 -ne "`wc -c lockbase.asm`"
then
echo shar: error transmitting lockbase.asm '(should have been 138 characters)'
fi
echo shar: extracting midilvo.asm '(606 characters)'
cat << \SHAR_EOF > midilvo.asm
; midilvo.asm - library routine definitions
; file created automatically by MakeLVO

	include "exec/types.i"
	include "exec/libraries.i"
	include "asmsupp.i"

	LIBINIT
	FUNCDEF LockMidiBase
	FUNCDEF UnlockMidiBase
	FUNCDEF CreateMSource
	FUNCDEF DeleteMSource
	FUNCDEF FindMSource
	FUNCDEF CreateMDest
	FUNCDEF DeleteMDest
	FUNCDEF FindMDest
	FUNCDEF CreateMRoute
	FUNCDEF ModifyMRoute
	FUNCDEF DeleteMRoute
	FUNCDEF MRouteSource
	FUNCDEF MRouteDest
	FUNCDEF MRoutePublic
	FUNCDEF GetMidiMsg
	FUNCDEF PutMidiMsg
	FUNCDEF FreeMidiMsg
	FUNCDEF MidiMsgType
	FUNCDEF MidiMsgLength
	FUNCDEF PutMidiStream

	end
SHAR_EOF
if test 606 -ne "`wc -c midilvo.asm`"
then
echo shar: error transmitting midilvo.asm '(should have been 606 characters)'
fi
echo shar: extracting modrte.asm '(237 characters)'
cat << \SHAR_EOF > modrte.asm
	public	_MidiBase,_LVOModifyMRoute

; ModifyMRoute (route,newrouteinfo)
; struct MRoute *route;
; struct MRouteInfo *newrouteinfo;

	public	_ModifyMRoute
_ModifyMRoute
	movem.l 4(sp),a0-a1
	move.l	_MidiBase,a6
	jmp	_LVOModifyMRoute(a6)

SHAR_EOF
if test 237 -ne "`wc -c modrte.asm`"
then
echo shar: error transmitting modrte.asm '(should have been 237 characters)'
fi
echo shar: extracting msglen.asm '(178 characters)'
cat << \SHAR_EOF > msglen.asm
	public	_MidiBase,_LVOMidiMsgLength

; MidiMsgLength (msg)
; UBYTE *msg;

	public	_MidiMsgLength
_MidiMsgLength
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOMidiMsgLength(a6)

SHAR_EOF
if test 178 -ne "`wc -c msglen.asm`"
then
echo shar: error transmitting msglen.asm '(should have been 178 characters)'
fi
echo shar: extracting msgtype.asm '(168 characters)'
cat << \SHAR_EOF > msgtype.asm
	public	_MidiBase,_LVOMidiMsgType

; MidiMsgType (msg)
; UBYTE *msg;

	public	_MidiMsgType
_MidiMsgType
	move.l	4(sp),a0
	move.l	_MidiBase,a6
	jmp	_LVOMidiMsgType(a6)

SHAR_EOF
if test 168 -ne "`wc -c msgtype.asm`"
then
echo shar: error transmitting msgtype.asm '(should have been 168 characters)'
fi
echo shar: extracting putmsg.asm '(200 characters)'
cat << \SHAR_EOF > putmsg.asm
	public	_MidiBase,_LVOPutMidiMsg

; PutMidiMsg (source,msg)
; struct MSource *source;
; UBYTE *msg;

	public	_PutMidiMsg
_PutMidiMsg
	movem.l 4(sp),a0-a1
	move.l	_MidiBase,a6
	jmp	_LVOPutMidiMsg(a6)

SHAR_EOF
if test 200 -ne "`wc -c putmsg.asm`"
then
echo shar: error transmitting putmsg.asm '(should have been 200 characters)'
fi
echo shar: extracting putstr.asm '(360 characters)'
cat << \SHAR_EOF > putstr.asm
	public	_MidiBase,_LVOPutMidiStream

; void PutMidiStream (source,fillbuffer,buf,bufsize,cursize)
; struct MSource *source;
; ULONG (*fillbuffer)();
; UBYTE *buf;
; ULONG bufsize,cursize;

	public	_PutMidiStream
_PutMidiStream
	movem.l a2,-(sp)
	movem.l 8(sp),a0-a2
	movem.l 20(sp),d0-d1
	move.l	_MidiBase,a6
	jsr	_LVOPutMidiStream(a6)
	movem.l (sp)+,a2
	rts

SHAR_EOF
if test 360 -ne "`wc -c putstr.asm`"
then
echo shar: error transmitting putstr.asm '(should have been 360 characters)'
fi
echo shar: extracting rtedst.asm '(301 characters)'
cat << \SHAR_EOF > rtedst.asm
	public	_MidiBase,_LVOMRouteDest

; struct MRoute *MRouteDest (sourcename,dest,midiinfo)
; char *sourcename;
; struct MDest *dest;
; struct MidiInfo *midiinfo;

	public	_MRouteDest
_MRouteDest
	movem.l a2,-(sp)
	movem.l 8(sp),a0-a2
	move.l	_MidiBase,a6
	jsr	_LVOMRouteDest(a6)
	movem.l (sp)+,a2
	rts

SHAR_EOF
if test 301 -ne "`wc -c rtedst.asm`"
then
echo shar: error transmitting rtedst.asm '(should have been 301 characters)'
fi
echo shar: extracting rtepub.asm '(307 characters)'
cat << \SHAR_EOF > rtepub.asm
	public	_MidiBase,_LVOMRoutePublic

; struct MRoute *MRoutePublic (sourcename,destname,routeinfo)
; char *sourcename,*destname;
; struct MRouteInfo *routeinfo;

	public	_MRoutePublic
_MRoutePublic
	movem.l a2,-(sp)
	movem.l 8(sp),a0-a2
	move.l	_MidiBase,a6
	jsr	_LVOMRoutePublic(a6)
	movem.l (sp)+,a2
	rts

SHAR_EOF
if test 307 -ne "`wc -c rtepub.asm`"
then
echo shar: error transmitting rtepub.asm '(should have been 307 characters)'
fi
echo shar: extracting rtesrc.asm '(317 characters)'
cat << \SHAR_EOF > rtesrc.asm
	public	_MidiBase,_LVOMRouteSource

; struct MRoute *MRouteSource (source,destname,routeinfo)
; Struct MSource *source;
; char *destname;
; Struct MRouteInfo *routeinfo;

	public	_MRouteSource
_MRouteSource
	movem.l a2,-(sp)
	movem.l 8(sp),a0-a2
	move.l	_MidiBase,a6
	jsr	_LVOMRouteSource(a6)
	movem.l (sp)+,a2
	rts

SHAR_EOF
if test 317 -ne "`wc -c rtesrc.asm`"
then
echo shar: error transmitting rtesrc.asm '(should have been 317 characters)'
fi
echo shar: extracting unlockba.asm '(148 characters)'
cat << \SHAR_EOF > unlockba.asm
	public	_MidiBase,_LVOUnlockMidiBase

; UnlockMidiBase()

	public	_UnlockMidiBase
_UnlockMidiBase
	move.l	_MidiBase,a6
	jmp	_LVOUnlockMidiBase(a6)

SHAR_EOF
if test 148 -ne "`wc -c unlockba.asm`"
then
echo shar: error transmitting unlockba.asm '(should have been 148 characters)'
fi
#	End of shell archive
exit 0