for reference purposes for all those interested in learning about + making music with the original hardware + software from the late 1980s + early 1990s thanks for visiting
Who | MIDI Interfaces | Software | TIMELINE | PCI | ISA | ATARI ST | DOS/PC | WIN/PC | MAC | Drums | Synths | Modules |Sequencers | Samplers | Tape Rec | Mix Consoles |
Artists | Recent | VST | ios inst | E-mu | Ensoniq | Akai "S" Series | Akai MPCs | Roland "S" Series | Drum Machines | Roland JV Addons | early 90s Synths | late 80s synths
guests are encouraged to: REGISTER to view file attachments + add relevant videos, downloads, resources. (credit your SOURCE!).to post a vid just paste url!

Recent Posts

1
https://web.archive.org/web/20010801172315/http://www.info.apple.com/support/oldersoftwarelist.html

Quote
Older Software Downloads

The following list of Software Downloads is for English North-American versions of Software for Macintosh, Apple II and Newton released prior to Mac OS 8.1 in January 1998. All software listed here is considered obsolete and may do harm if improperly installed. Please use extreme caution. All software released since January, 1998 is available in the AppleCare Knowledge Base (needs Apple ID), although there may be some duplicates listed here.

The information in this document, created and published on 17-July-2001, will not be updated with new content, nor will it be maintained (removing links to software no longer available).

Software is listed in alphabetical order by category, such as Apple II, Networking and Communications, Utilties, etc. We've added a name of Quick Clicks below to get you to the right category.

This list reflects the contents of the English North American directory on the Apple Software Downloads server. For software for other languages follow the same architecture format according to the language of your Macintosh Operating System.

2
https://books.google.ca/books/about/Machine_Musicianship.html?id=kSKC1QQarvwC
https://www.abebooks.com/Machine-Musicianship-Robert-Rowe-Press/9009316374/bd

ISBN 10: 0262182068 / ISBN 13: 9780262182065
Published by The MIT Press, 2001

Quote
Musicians begin formal training by acquiring a body of musical concepts commonly known as musicianship. These concepts underlie the musical skills of listening, performance, and composition. Like humans, computer music programs can benefit from a systematic foundation of musical knowledge. This book explores the technology of implementing musical processes such as segmentation, pattern processing, and interactive improvisation in computer programs. It shows how the resulting applications can be used to accomplish tasks ranging from the solution of simple musical problems to the live performance of interactive compositions and the design of musically responsive installations and Web sites.

Machine Musicianship is both a programming tutorial and an exploration of the foundational concepts of musical analysis, performance, and composition. The theoretical foundations are derived from the fields of music theory, computer music, music cognition, and artificial intelligence. The book will be of interest to practitioners of those fields, as well as to performers and composers.

The concepts are programmed using C++ and Max. The accompanying CD-ROM includes working versions of the examples, as well as source code and a hypertext document showing how the code leads to the program's musical functionality.
4
https://www.sweetwater.com/sweetcare/articles/utilize-quicktime-musical-instruments/

Quote
“I’d like to play the Quicktime Musical Instruments on my Mac using my MIDI controller, but I can’t seem to get them to work with the sequencer program I have. Is there extra software I need? What about the Apple MIDI Manager? I’ve looked for it but can’t seem to find it at Apple’s web site.” Yes, there is extra software you need, and no, it isn’t the Apple MIDI Manager. Actually, you can still find this program at Apple’s site, but the last update to it was in 1995. One reason for this is Opcode’s OMS was nearing the height of its popularity at that time, and replaced Apple’s MIDI application quite sufficiently. However, this isn’t to say OMS is your best or only option for MIDI on a Mac today. There is also FreeMIDI from Mark of the Unicorn (more on that in a bit). Opcode has been non-operational for quite a while since being purchased by Gibson Musical Instruments; in fact Gibson and Opcode haven’t made an ideal partnership to say the least. Long story short, all of Opcode’s products and development are ‘on-hold’ (with no apparent end in sight). So future upgrades for OMS don’t look promising, unless the program is made “open source”, meaning that anyone in the general software developing public who knows the application’s architecture and basic code could develop future versions to keep up with rapidly improving hardware (this is the way the Linux OS has been developed, for instance). This background is provided only to give some insight into the current Mac/MIDI app situation, and to help you, the users, decide what will work for you based on the facts at hand.MOTU’s FreeMIDI has become the heir apparent to OMS, though it still isn’t as roundly supported as OMS in the Mac/MIDI world. It is supported well enough to be a worthwhile application for MIDI, and is a logical current path to Mac/MIDI interactivity. Plus, both OMS and FreeMIDI can be running simultaneously, so you can cover all the bases in your MIDI setup, if you have the need.All this expository gobbledy-gook has been wonderful, hasn’t it? But we haven’t forgotten the real question at hand. How to use QuickTime Musical Instruments with OMS-compatible programs §If you don’t already have it, download the latest OMS from http://www.opcode.com/downloads. Run the installer, which should close all open programs, and restart your computer after the installation is complete. After restart, you should have the necessary OMS components in your extensions folder. You’ll also need the Quicktime extensions, which come installed on recent Macs.§Open your hard drive, open the OMS Applications folder, and double-click on OMS Setup. It will take you through a series of steps in order to configure your Mac and locate all applicable MIDI devices and ports. The Quicktime Instruments should be one of the ‘devices’ OMS finds; if it isn’t found, check your extensions to ensure all Quicktime items are present. After the setup is complete, your current OMS studio setup should be displayed in a window on your desktop. Click on the ‘Quicktime Music’ icon in the ‘My Studio Settings’ window and configure the ‘Quicktime Synth’ control via OMS. When OMS is set up, save your settings. Now you should be able to play the Quicktime Instruments with your MIDI controller, and sequence notes using an OMS-compatible sequencer. How to use Quicktime Musical Instruments with FreeMIDI-compatible programs §If you don’t already have it, download and install the latest FreeMIDI from http://www.motu.com.§Open your hard drive, open the FreeMIDI Applications folder, and double-click on FreeMIDI Setup. If you have already created a configuration, go to the File menu, and select FreeMIDI Preferences. You’ll need to create a FreeMIDI setup, which it can automatically do. It should find your FreeMIDI instruments and you’ll be all set. If it doesn’t for some reason make sure “Quicktime, Built-In” is checked in the preferences and try again. Now in your FreeMIDI Configuration, you will see a device called “Quicktime, Built-In” and you should also see your MIDI interface. If not, you may need a driver for it to work.Not only can you access the QuickTime MIDI externally, but also from within any FreeMIDI-compatible sequencers. You will be able to select Quicktime Built In channels 1-16 as output destinations.Also, the final version of Apple MIDI Manager is still available for download if you go to http://asu.info.apple.com/ and search software information for ‘midi manager’ (without the single quotes).

https://web.archive.org/web/20030804104035/http://developer.apple.com:80/documentation/quicktime/APIREF/SOURCESII/qtmidisendmidi.htm

https://web.archive.org/web/20030808164836/http://developer.apple.com:80/documentation/QuickTime/RM/PDF.htm
5
http://www.mactech.com/articles/mactech/Vol.05/05.11/MIDIToolSet/index.html

Quote
Apple's MIDI Manager   


By Don Veca, San Jose, CA

Introduction


The MIDI Manager is Apple’s new standard MIDI tool set. It enables developers to cleanly transfer MIDI data to and from synthesizers and other concurrently running applications. It supplies a complete MIDI tool set which is as powerful as any existing implementation, yet strictly adheres to system guidelines. Included with the MIDI Manager are the Apple MIDI Driver and PatchBay.

The Apple MIDI Driver interprets all incoming and out going MIDI messages and handles all serial port I/O. This includes various modes of time code generation and concurrent asynchronous serial port communication. PatchBay is Apple’s graphical user interface for the MIDI Manager. Supplied as a utility application and a Desk Accessory, PatchBay enables users to intuitively route MIDI data and time code to and from the Apple MIDI Driver as well as throughout multiple applications running under Multifinder. The MIDI Manager proper, however, supplies all internal communications and supplies a thorough and very powerful MIDI tool set.

Main Concepts


From the music software developer’s point of view, the main components of the MIDI Manager are clients and ports. A client is any program that uses the MIDI Manager’s facilities. Although an application usually needs only one client, it can actually have several. Each client can, and usually does, create multiple ports which are basically unidirectional streams of MIDI information. Each port can be either a time port, which provides the MIDI Manager’s timing facilities, or a data port, which is used to read or write MIDI packets. The data ports are further divided into input and output ports. A client’s ports can be connected to one of its own ports or to any other client’s ports; however, input ports can only be connected to output ports (and vice versa). Time ports enable port synchronization: when a time port’s clock ticks, all clocks of all ports connected to it tick synchronously. Data ports send and receive MIDI data such as note-on/note-off or system exclusive messages. Input and output ports respectively receive and send MIDI data to the ports of MIDI drivers or other MIDI Manager compatible applications running concurrently under Multifinder. We will now illustrate the proper use of the MIDI Manager through the explanation of a sample application called MIDIArp.

The MIDIArp Demo Application


MIDIArp is a simple arpeggiator program [tone generator for those who are not blessed with a huge vocabulary like Don’s. -ed] that illustrates the use of the MIDI Manager’s data and timing facilities. MIDIArp simply reads in note-on data and arpeggiates it until corresponding note-off data is received. The basic flow of MIDIArp is quite simple: after MIDIArp initializes the various Macintosh Managers, it signs into the MIDI Manager, calls a routine to set up its time, input, and output ports, pops up its main dialog box, and cycles through its main event loop. The main event loop simply checks for user (console) input, and adjusts its arpeggio direction and speed parameters accordingly. Once the quit button is selected, MIDIArp signs out from the MIDI Manager and terminates. During the main event loop, however, MIDIArp continually arpeggiates its MIDI input at interrupt level via its readHook and timeProc routines.

MIDIArp.h


MIDIArp includes a header file, MIDIArp.h, which contains its main data structures and symbolic constants. In addition to the standard user interface constants for menu and dialog resource ID’s, constants are defined to identify our own resource of type ‘port’. We define three such ‘port’ resources: one for each MIDI Manager port we intend to use. This is necessary in order to save the state of our patch between each launch of the application. For readability, several MIDIArp constants are defined followed by several constants local to the MIDI Manager itself. Specifically, we define our client and ‘ICN#’ resource ID, both of which are used to sign in to the MIDI Manager. The client ID is a four-byte OSType (and by convention, although not by necessity, our client ID is used as our application signature). We then define our port ID’s which are also of type OSType. The actual ports will be displayed by PatchBay from top to bottom in ascending alphabetical order. (It is recommended that time ports be displayed above the data ports that are synchronized to them, and that an application’s input and output ports be displayed in the reverse order of that used by the Apple MIDI Driver.)

After several MIDI Manager parameters are symbolically defined, we define our main data structures. The first data structure that we will need is a NoteInfo record which contains fields to store the MIDI channel, key number, and key velocity of each incoming note-on message. The NoteInfo record is itself an individual field of the main MIDIArp data structure ArpParams. The ArpParams structure contains various fields of information concerning the current state of the MIDIArp client. In particular, it contains a field called Locked, which is used to prevent the structure from being modified while it is in use. Incoming MIDI data (notes that MIDIArp is currently arpeggiating) are stored in an array of NoteInfo records called NoteTbl. Other fields hold information about things such as tempo and current arpeggiation pattern (e.g., whether we are currently going up or down, etc.). NextNoteOn is a field used to keep track of the exact time the next note is to be played. Finally, the ArpParams structure allows the storage of each port’s reference number.



MIDIArp.c


The main source file for MIDIArp is MIDIArp.c. Here we first define several global variables, including an ArpParams record called ArpGlobals, a variable to hold our current arpeggiation speed ID, and a flag (GManualPatch) to indicate whether the current port configuration (patch) has been set up by a (previously saved) PatchBay patch or needs to be reconfigured by MIDIArp itself (based on its last configuration). The main() routine of MIDIArp calls InitThings() to initialize the Macintosh Managers, ArpInit() which signs-in to the MIDI Manager and sets up our ports, StartDialog() to bring up the main dialog box with default settings, and then RunDialog() to handle events. When the Quit button is finally hit, ArpClose() is called to sign-out from the MIDI Manager, and the main dialog box is shut down through a call to StopDialog(). InitThings(), in addition to initializing the various managers of the Macintosh, sets up a standard menu bar and seeds the random number generator for random arpeggiation. ArpInit(), on the other hand, completely sets up MIDIArp’s MIDI Manager environment. In order to use the MIDI Manager we must first make sure that it is currently installed. This is achieved through a call to SndDispVersion() (sound dispatch version). Given the constant midiToolNum, SndDispVersion() returns the version of the currently installed MIDI Manager or zero if the MIDI Manager is not installed. Once we have concluded that the MIDI Manager is installed, we must sign in to the MIDI Manager (before we make any other calls) by calling MIDISignIn(). We pass as arguments to MIDISignIn() our client ID, our client reference constant, a handle to our ‘ICN#’ resource, and our client name string. The client ID is used for future MIDI Manager calls and allows other clients, such as patchers, to get information about us. The client reference constant, or refCon, is a general purpose parameter that is only really needed by certain types of applications (such as device drivers). The handle to the ‘ICN#’ resource and the client name string are passed to allow PatchBay (or any other clients) to display them via MIDIGetClientIcon() and MIDIGetClientName(), respectively.

The next thing we do in ArpInit() is add our time, input, and output ports via MIDIAddPort() and connect them accordingly. The tricky part is determining whether the ports will automatically be connected via a saved PatchBay patch, or whether we must connect them ourselves. Therefore, we set the global flag GManualPatch to true before we add any ports allowing us to determine by the return value of MIDIAddPort() whether or not we need to connect the ports ourselves. If MIDIAddPort() returns midiVConnectMade (virtual connection resolved), then we know that the ports were virtually connected by someone else via MIDIConnectTime() or MIDIConnectData(). In this case we simply set GManualPatch to false indicating that we do not have to manually patch together the ports. If GManualPatch is still true after all ports have been added, then we will call PatchPorts() to do our own patching.

The first port we add in ArpInit() is our time port or time base. We do this by calling MIDIAddPort(). This call will create a new port with attributes as described in an InitParams data structure; therefore, we must first set one up. The init record contains various information including items such as the port ID, the port type (time, input, output, invisible time) the port’s readHook, the time format, port name, etc., and a port reference constant (refCon). If the port’s readHook routine is to be called at interrupt level, then the refCon can be used to store the contents of the application’s A5 register for global variable access. The same basic strategy is used for creating the input and output ports; however, MIDIArp by default wants its data ports to be sync’d to its time port. So before we actually add the port, we set the timeBase field of the InitParams record to our time port’s reference number (previously obtained when we added our time port).

Now that all the ports have been added, we check GManualPatch, and, if it’s still true, we call PatchPorts() to patch the ports as they were when we last quit. To reconfigure our port connections, we must read in the ‘port’ resource of each port. The port resource is nothing more than the saved result of MIDIGetPortInfo() from our last session. MIDIGetPortInfo() returns a handle to a record containing the port type, time base of the port, and a list of all its connections.

To reconfigure our time port, we first check its port info record (of its ‘port’ resource) to see if we should be sync’d to another client’s time base. If so, we call MIDIConnectTime(), connecting the external time port to our time port (slaving us to it). If the result of MIDIConnectTime() is midiVConnectErr, then the external port’s owner is not currently signed in; otherwise, we must set our sync mode to externalSync. Next, we check to see if we are supposed to be the time base of one or more external ports. If so, we connect our time port to each.

It’s a little less complicated to reconfigure our input and output ports. All we have to do is connect our input and output port to each of the ports listed in the PortInfo record contained in the corresponding ‘port’ resource. The last thing we need to do in ArpInit() is start our time port’s clock by calling MIDIStartTime(). Now that everything is set up, we simply cycle through our main event loop, waiting for the MIDI Manager to call our readHook routine with incoming MIDI data.

In addition to handling user events, the main event loop periodically checks to see if an external time base has suddenly been connected to us. This is achieved by first detecting that “something in MIDI Manager world has changed,” and then by checking our time port’s info record to see if the MIDI Manager reports that we currently have an external time base. This situation arises if another client attempts to connect themselves to us or if a user of a patcher program (such as Patchbay) manually connects an external time port to ours. We check for either event in our main event loop by calling MIDIWorldChanged(). If MIDIWorldChanged() returns true, then we know that something in the current world has changed; however, this could be caused by a client signing in or out, a port being added or removed, or a connection being made or removed. Therefore, we must call MIDIGetPortInfo() on our time port and check whether the returned port information record reports that we currently have an external time base. If so, we then set our time port to external sync via MIDISetSync(); otherwise, we set it back to midiInternalSync (in the case that we were currently in external sync mode). The only thing left now is to get and process incoming MIDI data; this operation is handled at interrupt level through use of a readHook and a timeProc routine.

Before jumping into the details, a general explanation of the interrupt level control flow of MIDIArp’s readHook and timeProc is needed. The readHook is called by the MIDI Manager whenever an incoming message becomes “current.” When the first note of an input sequence is sent to MIDIArp’s input port, the MIDI Manager calls MIDIArp’s readHook which then copies it into the application’s note table buffer and calls the timeProc to take care of the output. When called, the timeProc determines the next note in the note table to be played, writes out the selected note, and then tells the MIDI Manager exactly when to call the timeProc for the next output. In other words, the only time the MIDIArp application calls its timeProc is from within its readHook, and this is done only when it receives the first note of an input sequence. After that, the timeProc itself is responsible for setting up its next wake-up.

As summarized above, MIDIArp’s readHook ArpReader() reads all incoming data, and starts a series of timeProc wake-ups which create the arpeggiation effect. As you may recall, the refCon field of the initialization record of each port was set to point to our application’s global variables and passed as an argument to MIDIAddPort() when the port was originally created; additionally, the readHook field of the input port’s initialization record was set to the address of ArpReader(). When the MIDI Manager calls a port’s readHook, it passes two parameters: the next “current” MIDIPacket, and the port’s refCon value. Because the MIDI Manager calls ArpReader() at interrupt level, the readHook first sets up our A5 world. This is achieved by calling the System routine SetA5() with the refCon parameter. Since we will be modifying the note table in the ArpGlobals record, we must check whether any other routine is currently reading it by checking the Locked field. If it is locked, we simply return midiKeepPacket, which tells the MIDI Manager to save the new packet -- we’ll get it later. The packet is of interest to MIDIArp only if it is does not contain a MIDI Manager system specific message (indicated in the message type field of the flags byte), and does contain a note-on message. If these conditions are satisfied, then we set the return value to midiMorePacket, telling the MIDI Manager that we now have this packet and that we want the next one.

Before we actually return, however, we process the current packet. If the status byte in the packet indicates a note-on message, then we copy it into our note table and increment our current note count. If our note count is now equal to 1 (i.e., this is the first note of an arpeggio), then we call ArpTimeProc() to initiate an arpeggiation. (ArpTimeProc() is the routine that actually writes out the MIDI data.) If the status byte in the packet is a note-off message, however, we locate the matching note in the note table; and, if it’s still a valid note (it didn’t get “stolen”), then we simply delete it from the note table and decrement the table’s current note count NumNotes. (A note can get “stolen” if there are 32 notes in our note table and a new note that is lower than the highest note is inserted.) Finally, we restore the system’s A5 world and return.

As mentioned above, we call our timeProc ArpTimeProc() from our readHook ArpReader() when we get the first note of an arpeggiation series. However, it is quite common for the MIDI Manager to call a timeProc at interrupt level (per an application scheduled event that will be illustrated below). This can be set up by calling the MIDI Manager routine MIDIWakeUp() with several arguments which include the reference number of a specific time port, a time, a period, and a pointer to the timeProc. In this case, the MIDI Manager calls the timeProc with the time port’s current time and refCon.

When our readHook ArpReader() calls our timeProc ArpTimeProc(), however, it passes it the time stamp of the current MIDI packet (which in this case is not used) and the refCon parameter that was passed to ArpReader(). (The refCon of each port points to MIDIArp’s global variables.) Once in control, the timeProc again sets up MIDIArp’s A5 world via its refCon parameter (because it may be called by the MIDI Manager as well as from within the readHook). We then lock the ArpGlobals structure so that ArpReader() won’t disturb it. If at this time there are no notes in our note table, then we simply cancel any pending wake-ups and return. Otherwise, we bump the note table index to the next note to be played. However, we must avoid the special case where the first note of an arpeggio may unintentionally be played twice in a row. (For example, the arpeggiation pattern is “Up,” two notes are struck “at same time,” and the first note received is higher than the second note. The first note received gets index 0, noteTbleIndex is set to 0, and the note is played. When the next note is received, the previous note is moved to index 1, the new note is inserted into index 0, and the noteTblIndex is bumped to index 1, which is the note that gets played. This means that the first note will be perceived to be played twice!) To avoid this sequence of events, if the note that we played the last time the ArpTimeProc() was called (LastNote) is the same note as our new one, then we bump the note index once more. Now we can finally write out a note-on message by calling MIDIWritePacket(). And, because we know the duration of the note, we we can write out its corresponding note-off by simply adjusting the time stamp and calling MIDIWritePacket() again with the same packet. The MIDI Manager will make sure that the packet is actually written out at the specified time.

The last thing we do in ArpTimeProc() is schedule the time that the MIDI Manager should call ArpTimeProc() to write out the next note (this is what creates the arpeggio effect). We first set NextNoteOnTime to itself plus the value of Tempo; however, we want the ArpTimeProc() to be called (and write out the packet) soon enough before NextNoteOnTime such that the next call to MIDIWritePacket() will be before the packet’s time stamp expires. Although we call MIDIWritePacket() with an accurately time-stamped packet, we call it early to avoid the chance of the note being received late due to processing time. The basic rule of thumb is to always write early, making sure that the time stamp (which is some time in the future) is accurate. Finally, we unlock the ArpGlobals structure, restore the system’s A5 world, and return.

And that’s it! The readHook continues reading incoming MIDI data, and the timeProc continues scheduling it to be written out. This continues until the user hits the Quit button. When this happens, we call ArpClose() to save our current patch configuration into the applications ‘port’ resource and sign-out from the MIDI Manager.

How to Put It All Together


Before running MIDIArp, however, the MIDI Manager must be installed. Installation consists of nothing more than moving the MIDI Manager and Apple MIDI Driver files into the System folder and restarting the Macintosh. Once the MIDI Manager is installed, PatchBay and any other MIDI Applications can be launched.

Under single Finder, use the PatchBay DA to connect a single application to and from the Apple MIDI Driver; under MultiFinder however, use the PatchBay application. Once PatchBay and one or more MIDI-Manager-compatible applications or drivers are up and running, the input, output, and time ports of the applications or drivers can be connected to themselves, other applications, and to the Apple MIDI Driver in any proper configuration.

When a MIDI instrument is connected to the Macintosh and MIDIArp is launched, the mouse can be used used to connect MIDIArp’s output port to the Apple MIDI Driver’s input port, and to connect the MIDI Driver’s output port to MIDIArp’s input port. (The MIDI Driver’s input port can be thought of as the Macintosh’s output port and visa versa). In this configuration, MIDIArp will continue to arpeggiate (in various patterns and at various tempos) the note data output of one or more interfaced MIDI instruments or any other MIDI-Manager-compatible applications, desk accessories, or drivers.

Where to Get the MIDI Manager


The MIDI manager is currently available to developers through APDA and may possibly be shipped with future System Disks. The MIDIArp sample application (and several other samples) are included on the APDA disk as well. Although there are no MIDI-Manager-compatible third party applications available at the time of this writing, various Macintosh MIDI developers are currently working toward MIDI Manager compatibility, and it is likely that many third party application packages will become available in the near future.

[The full listing is not included due to licensing concerns; you may however get the MIDI manger and PatchBay on the source code disk for this issue, #50. -ed]

 /*
 For commented, properly 
 formatted, and complete
 source code, please refer
 to the MacTutor source
 listing disk for this issue.
*/
/*** MIDIArp.h ***/
#define mainDialogID 2000
#define quitID   1
#define patternPromptID   2
#define patternUpID3
#define patternDownID4
#define patternUpDownID   5
#define patternDownUpID   6
#define patternRandomID   7
#define speedPromptID8
#define speedVeryFastID   9
#define speedFastID10
#define speedMediumID11
#define speedSlowID12
#define speedVerySlowID   13
#define arpAlertBoxID12345
#define arpAboutAlertID   13554
#define portResType‘port’
#define timePortResInfoID 128
#define inputPortResInfoID129
#define outputPortResInfoID 130 
#define noteTblSize32
#define goingUp  1
#define goingDown0
#define speedVeryFast50   
#define speedFast100
#define speedMedium200
#define speedSlow300
#define speedVerySlow500
#define noteDuration  (ArpGlobals.Tempo * 0.95)
#define arpClientID‘MArp’
#define arpIcon  128
#define timePortID ‘Atim’
#define inputPortID‘Bin ‘
#define outputPortID ‘Cout’
#define keyOnOffPacketSize9
#define stdPacketFlags    0
#define flagsTimeStampMask0x7F
#define noTimeBaseRefNum  0
#define noClient ‘    ‘
#define noReadHook 0L
#define noTimeProc 0L
#define zeroTime 0L
#define zeroPeriod 0L
#define refCon0  0L
#define timePortBuffSize  0L
#define inputPortBuffSize 2048
#define outputPortBuffSize0L
 
typedef struct
{unsigned char Channel;
 unsigned char Note;
 unsigned char Velocity;
 unsigned char Dummy;
} NoteInfo;
typedef struct
{short  Locked;
 NoteInfo NoteTbl[noteTblSize];
 long   NoteIndex;
 short  NumNotes;
 NoteInfo LastNote;
 short  ArpPattern;
 short  ArpDirection;
 long   Tempo;
 long   NextNoteOnTime;
 short  InputRefNum;
 short  OutputRefNum;
 short  TimeRefNum;
} ArpParams;

/*************
 MIDIArp.c
*************/
 // Include Standard Mac Headers
#include <MIDI.h>
#include “MIDIDefs.h”
#include “MIDIArp.h”

DialogPtr GMainDialog; 
ArpParams ArpGlobals;
short   GCurSpeedID;
Boolean GManualPatch;
Boolean GDone = false; 
char    GMIDIMgrVerStr[256];

main()
{
 InitThings();
 ArpInit();
 StartDialog(); 
 RunDialog(); 
 ArpClose();
 StopDialog();
}
 
void InitThings(void)
{
 FlushEvents(everyEvent, 0);
 InitGraf(&qd.thePort);   
 InitFonts();   
 InitWindows(); 
 InitMenus();   
 TEInit();
 InitDialogs(NULL);
 InitCursor();   
 
 {
 Handle MenuBar = GetNewMBar(menuBar);
 SetMenuBar(MenuBar);
 DisposHandle(MenuBar);
 AddResMenu(GetMHandle(appleMenu), ‘DRVR’); 
 DrawMenuBar();
 }
 
 Seed(); // Rand Num Generator
}

void ArpInit(void)
{
 MIDIPortParams  Init; 
 Handle TheIconHndl;
 OSErr  TheErr;
 long   MIDIMgrVerNum; 
 char   CStrBuf1[256];
 
 MIDIMgrVerNum = SndDispVersion(midiToolNum);
 if (MIDIMgrVerNum == 0)
 {
 ArpAlert(“The MIDI Manage is not installed! 
 Aborting...”);
 ExitToShell();
 }
 else
 {
 StdMacVerNumToStr(MIDIMgrVerNum, GMIDIMgrVerStr);
 sprintf(CStrBuf1,”MIDI Manager Version %s”,
 GMIDIMgrVerStr);
 ArpAlert(CStrBuf1);
 }
 
 TheIconHndl = GetResource(‘ICN#’, arpIcon);
 TheErr = MIDISignIn(arpClientID, refCon0,
 TheIconHndl, “\pMIDIArp”);
 if (TheErr)
 {
 ArpAlert(“Trouble signing MIDIArp into MIDI
 Manager!  Aborting...”);
 ExitToShell();
 }
 
 GManualPatch = true;
 
 Init.portID = timePortID;
 Init.portType = midiPortTypeTime;
 Init.timeBase = noTimeBaseRefNum;
 Init.readHook = noReadHook;
 Init.initClock.sync = midiInternalSync;
 Init.initClock.curTime = zeroTime;
 Init.initClock.format =  midiFormatMSec;
 Init.refCon = SetCurrentA5();
 C2PStrCpy(“TimeBase”,Init.name);
 TheErr = MIDIAddPort(arpClientID, timePortBuffSize,
 &(ArpGlobals.TimeRefNum), &Init);
 
 if (TheErr == midiVConnectMade)
 {
 GManualPatch = false;
 }
 else if (TheErr == memFullErr)
 {
 ArpAlert(“Not enough room in
 heap zone to add time
 port!  Aborting...”);
 MIDISignOut(arpClientID);
 ExitToShell();
 }
 
 Init.portID = inputPortID;
 Init.portType = midiPortTypeInput;
 Init.timeBase = ArpGlobals.TimeRefNum;
 Init.offsetTime = midiGetCurrent;
 Init.readHook = (Ptr) ArpReader;
 Init.refCon = SetCurrentA5();
 C2PStrCpy(“InputPort”, Init.name);
 TheErr = MIDIAddPort(arpClientID, inputPortBuffSize,
 &(ArpGlobals.InputRefNum), &Init);
 
 if (TheErr == midiVConnectMade)
 {
 GManualPatch = false;
 }
 else if (TheErr == memFullErr)
 {
 ArpAlert(“Not enough room in heap zone to add input
 port!  Aborting...”);
 MIDISignOut(arpClientID);
 ExitToShell();
 }
 
 Init.portID = outputPortID;
 Init.portType = midiPortTypeOutput;
 Init.timeBase = ArpGlobals.TimeRefNum;
 Init.offsetTime = midiGetCurrent;
 Init.readHook = NULL;
 Init.refCon = &ArpGlobals;
 C2PStrCpy(“OutputPort”, Init.name);
 TheErr = MIDIAddPort(arpClientID, outputPortBuffSize,
 &(ArpGlobals.OutputRefNum), &Init);
 
 if (TheErr == midiVConnectMade)   {
 GManualPatch = false;
 }
 else if (TheErr == memFullErr)
 {
 ArpAlert(“Not enough room in heap zone to add output
 port!  Aborting...”);
 MIDISignOut(arpClientID);
 ExitToShell(); 
 }
 
 if (GManualPatch)
 {
 PatchPorts();
 }
 
 ArpGlobals.Locked = false;
 ArpGlobals.NumNotes = 0;
 ArpGlobals.ArpPattern = patternUpDownID;
 ArpGlobals.Tempo = speedMedium;
 GCurSpeedID = speedMediumID;
 
 MIDIStartTime(ArpGlobals.TimeRefNum);
}

void StartDialog(void)
{
 GMainDialog = GetNewDialog(mainDialogID,
 NULL, (WindowPtr) -1);
 SetPort(GMainDialog);
 
 ChangeState(GMainDialog, ArpGlobals.ArpPattern ==
 patternUpID, patternUpID);
 ChangeState(GMainDialog, ArpGlobals.ArpPattern ==
 patternDownID, patternDownID);
 ChangeState(GMainDialog, ArpGlobals.ArpPattern ==
 patternUpDownID, patternUpDownID);
 ChangeState(GMainDialog, ArpGlobals.ArpPattern ==
 patternDownUpID, patternDownUpID);
 ChangeState(GMainDialog, ArpGlobals.ArpPattern ==
 patternRandomID, patternRandomID);
 
 ChangeState(GMainDialog, GCurSpeedID ==
 speedVeryFastID, speedVeryFastID);
 ChangeState(GMainDialog, GCurSpeedID == speedFastID,
 speedFastID);
 ChangeState(GMainDialog, GCurSpeedID ==
 speedMediumID, speedMediumID);
 ChangeState(GMainDialog, GCurSpeedID == speedSlowID,
 speedSlowID);
 ChangeState(GMainDialog, GCurSpeedID ==
 speedVerySlowID, speedVerySlowID);
 
 ShowWindow(GMainDialog);
 StdAdjustDLOGLocation(GMainDialog);
}

void RunDialog(void)
{
 OSErr  TheErr = noErr;
 short  ItemHit;
 EventRecordAnEvent;
 WindowPtrWhichWindow;
 Rect   Boundry;
 MIDIPortInfoHdl PortInfoH;
 GrafPtrSavePort;

 while (!GDone) {
 if (MIDIWorldChanged(arpClientID))
 {
 PortInfoH = MIDIGetPortInfo(arpClientID, timePortID);
 if ((**PortInfoH).timeBase.clientID != noClient)
 {
 MIDISetSync(ArpGlobals.TimeRefNum, midiExternalSync);
 }
 else
 {
 MIDISetSync(ArpGlobals.TimeRefNum, midiInternalSync);
 }
 DisposHandle((Handle) PortInfoH);
 }
 
 if (WaitNextEvent(everyEvent,&AnEvent, updatePeriod,NULL))
 {
 
 if ((AnEvent.what == keyDown) && (AnEvent.modifiers
 & cmdKey))
 {
 AdjustMenus();
 DoMenuCommand(MenuKey(AnEvent.message & charCodeMask)
 );
 }
 
 if (IsDialogEvent(&AnEvent))
 {
 if (AnEvent.what == updateEvt)
 {
 GetPort(&SavePort);
 SetPort((GrafPtr) AnEvent.message);
 StdHiliteButton(GMainDialog, quitID);
 SetPort(SavePort);
 }
 
 if (AnEvent.what == keyDown &&
 ((AnEvent.message & charCodeMask)
 == charEnterKey))
 {
 GDone = true;
 }
 else if (
 DialogSelect(&AnEvent, &GMainDialog, &ItemHit))
 {
 switch (ItemHit)
 {
 case quitID:
 GDone = true;
 break;
 
 case
 patternUpID:
 case
 patternDownID:
 case
 patternUpDownID:
 case   
 patternDownUpID:
 case
 patternRandomID:
 SwitchRadio(GMainDialog, &(ArpGlobals.ArpPattern),
 ItemHit);
 break;
 
 case
 speedVeryFastID:
 ArpGlobals.Tempo = speedVeryFast;
 SwitchRadio(GMainDialog, &GCurSpeedID, ItemHit);
 break;
 
 case
  speedFastID:
 ArpGlobals.Tempo = speedFast;
 SwitchRadio(GMainDialog,&GCurSpeedID, ItemHit);
 break;
 
 case
  speedMediumID:
 ArpGlobals.Tempo = speedMedium;
 SwitchRadio(GMainDialog, &GCurSpeedID, ItemHit);
 break;
 
 case
 speedSlowID:
 ArpGlobals.Tempo = speedSlow;
 SwitchRadio(GMainDialog, &GCurSpeedID, ItemHit);
 break;
 
 case
  speedVerySlowID:
 ArpGlobals.Tempo = speedVerySlow;
 SwitchRadio(GMainDialog, &GCurSpeedID, ItemHit);
 break;
 
 default:
 SysBeep(2);
 break;
 }
 }
 }
 else {
 switch (AnEvent.what)
 {
 case mouseDown:
 switch(FindWindow(AnEvent.where,
 &WhichWindow) )
 {
 case
 inMenuBar:
 AdjustMenus();
 DoMenuCommand(
 MenuSelect(AnEvent.where));
 break;

 case
 inSysWindow:
 SystemClick(&AnEvent, WhichWindow);

 break;
 case
 inContent:
 if (WhichWindow != FrontWindow())
 {
 SelectWindow(WhichWindow);
 AdjustMenus();
 }
 break;
 case
 inGoAway:
 if (TrackGoAway(WhichWindow,AnEvent.where))
 {
 GDone = true;
 }
 break;
 case
 inDrag:
 SetRect(&Boundry, 4, 24,
 qd.screenBits.bounds.right - 4,
 qd.screenBits.bounds.bottom - 4);
 
 DragWindow(WhichWindow,AnEvent.where,&Boundry);
 break;
 default:
 break;
 }
 break;
 
 default:
 break;
 }
 }
 }
 } 
}

void ArpClose(void)
{
 if (GManualPatch)
 {
 SavePatch(timePortID, timePortResInfoID, “timePortInfo”);

 SavePatch(inputPortID, inputPortResInfoID,
 “inputPortInfo”);

 SavePatch(outputPortID, outputPortResInfoID,
 “outputPortInfo”);
 }
 MIDISignOut(arpClientID);
}

void StopDialog(void)
{
 StdSaveDLOGLocation(GMainDialog, mainDialogID);
 HideWindow(GMainDialog);
 DisposDialog(GMainDialog);
}

pascal short
ArpReader(MIDIPacket *ThePacketPtr, long TheRefCon)
{
 long SysA5 = SetA5(TheRefCon);
 short  RetVal = midiMorePacket, i, j;
 
 if(ArpGlobals.Locked)
 {
 RetVal = midiKeepPacket;
 }
 else if ( ThePacketPtr->flags == stdPacketFlags
 && ((ThePacketPtr->data[0] & statusMask)
 == keyOn || (ThePacketPtr->data[0]
   & statusMask) == keyOff))
 {
 RetVal = midiMorePacket;
 if ((ThePacketPtr->data[0] & statusMask)
 == keyOn && ThePacketPtr->data[2] != zeroVelo)
 {
 for (i=0; i<ArpGlobals.NumNotes; i++)
 {
 if   (ThePacketPtr->data[1] <=
 ArpGlobals.NoteTbl.Note)
 {
 break;
 }
 }
 for(j=ArpGlobals.NumNotes; j>i; j--)
 {
 ArpGlobals.
 NoteTbl[j].Channel = ArpGlobals.NoteTbl[j-1].Channel;
 ArpGlobals.
 NoteTbl[j].Note = ArpGlobals.NoteTbl[j-1].Note;
 ArpGlobals.
 NoteTbl[j].Velocity = ArpGlobals.NoteTbl[j-1].
 Velocity;
 }
 ArpGlobals.NoteTbl.Channel = ThePacketPtr->data[0]
 & channelMask;
 ArpGlobals.NoteTbl.Note = ThePacketPtr->data[1];
 ArpGlobals.NoteTbl.Velocity = ThePacketPtr->data[2];
 
 if(ArpGlobals.NumNotes < noteTblSize)
 {
 ArpGlobals.NumNotes++;
 }
 if(ArpGlobals.NumNotes == 1)
 {
 ArpGlobals.NextNoteOnTime = ThePacketPtr->tStamp;
 ArpTimeProc(ThePacketPtr->tStamp, TheRefCon);                 }
 }
 else if ((ThePacketPtr->data[0] &
 statusMask) == keyOff || (ThePacketPtr->data[0] &
 statusMask) == keyOn)
 {
 for (i=0; i< ArpGlobals.NumNotes; i++)
 {
 if((ArpGlobals.NoteTbl.Channel ==
 (ThePacketPtr->data[0] & channelMask))
 && (ArpGlobals.NoteTbl.Note == ThePacketPtr->data[1]))
 {
 break;
 }
 }
 
 if (i < ArpGlobals.NumNotes)
 {
 
 for (/*i=i*/; i<ArpGlobals.NumNotes-1; i++)
 {
 ArpGlobals.NoteTbl.Channel =
 ArpGlobals.NoteTbl[i+1].Channel;
 ArpGlobals.NoteTbl.Note =
 ArpGlobals.NoteTbl[i+1].Note;
 ArpGlobals.NoteTbl.Velocity =
 ArpGlobals.NoteTbl[i+1].Velocity;
 }
 ArpGlobals.NumNotes--;
 }
 }
 }
 
 SetA5(SysA5);
 return(RetVal);
}

pascal void ArpTimeProc(long , long TheRefCon)
{
 long SysA5 = SetA5(TheRefCon);
 int    i;
 MIDIPacket TheMIDIPacket;
 
 ArpGlobals.Locked = 1;

 if (ArpGlobals.NumNotes == 0)
 {
 MIDIWakeUp(ArpGlobals.TimeRefNum, zeroTime,
 zeroPeriod, noTimeProc);
 }
 else
 {
 BumpNoteTableIndex();
 if (ArpGlobals.NoteTbl [ArpGlobals.NoteIndex]
 == ArpGlobals.LastNote)
 {
 BumpNoteTableIndex();
 }
 ArpGlobals.LastNote = ArpGlobals.NoteTbl[
 ArpGlobals.NoteIndex];
 
 TheMIDIPacket.flags = stdPacketFlags;
 TheMIDIPacket.len = keyOnOffPacketSize;
 
 i = ArpGlobals.NoteIndex;
 TheMIDIPacket.tStamp = ArpGlobals.NextNoteOnTime;
 TheMIDIPacket.data[0] = ArpGlobals.NoteTbl.
 Channel | keyOn;
 TheMIDIPacket.data[1] = ArpGlobals.NoteTbl.Note;
 TheMIDIPacket.data[2] = ArpGlobals.NoteTbl.Velocity;
 MIDIWritePacket(ArpGlobals.OutputRefNum, &TheMIDIPacket);
 
 TheMIDIPacket.tStamp += noteDuration;
 TheMIDIPacket.data[0] -= 0x10; 
 MIDIWritePacket(ArpGlobals.OutputRefNum, &TheMIDIPacket);
 
 ArpGlobals.NextNoteOnTime += ArpGlobals.Tempo;         
 MIDIWakeUp(ArpGlobals.TimeRefNum,
 ArpGlobals.NextNoteOnTime - ArpGlobals.Tempo/2,
 zeroPeriod, (ProcPtr) ArpTimeProc);
 }
 ArpGlobals.Locked = false;
 
 SetA5(SysA5);
}

void BumpNoteTableIndex(void)
{
 if (ArpGlobals.NumNotes == 1)
 {
 ArpGlobals.NoteIndex = 0;
 }
 else
 {
 switch(ArpGlobals.ArpPattern)
 {
 case patternUpID:
 if (ArpGlobals.NoteIndex >= ArpGlobals.
 NumNotes-1)
 {
 ArpGlobals.NoteIndex = 0;
 }
 else
 {
 ArpGlobals.NoteIndex++;
 }
 break;
 
 case patternUpDownID:   
 case patternDownUpID:
 if (ArpGlobals.ArpDirection == goingUp)
 {
 
 if (ArpGlobals.NoteIndex >
 ArpGlobals.NumNotes-1)
 {
 ArpGlobals.NoteIndex = ArpGlobals.NumNotes-1;
 ArpGlobals.ArpDirection = goingDown;
 }
 else if (ArpGlobals.NoteIndex ==
 ArpGlobals.NumNotes-1)
 {
 ArpGlobals.NoteIndex--;
 ArpGlobals.ArpDirection = goingDown;
 }
 else
 {
 ArpGlobals.NoteIndex++;
 }
 }
 else
 {
 if (ArpGlobals.NoteIndex < 0)
 {
 ArpGlobals.NoteIndex = 0;
 ArpGlobals.ArpDirection = goingUp;
 }
 else if (ArpGlobals.NoteIndex == 0)
 {
 ArpGlobals.NoteIndex++;
 ArpGlobals.ArpDirection = goingUp;
 }
 else
 {
 ArpGlobals.NoteIndex--;
 }
 }
 break;
 
 case patternDownID:
 if (ArpGlobals.NoteIndex <= 0)
 {
 ArpGlobals.NoteIndex = ArpGlobals.
 NumNotes-1;
 }
 else
 {
 ArpGlobals.NoteIndex--;
 }
 break;
 
 case patternRandomID:
 ArpGlobals.NoteIndex
 = Choose(ArpGlobals.NumNotes);
 break;
 }
 }
}

void PatchPorts(void)
{
 MIDIPortInfoHdl PortInfoH;
 MIDIPortInfoPtr PortInfoP;
 short  i, TheErr;
 
 PortInfoH = (MIDIPortInfoHdl)
 GetResource(portResType, timePortResInfoID);
 if (PortInfoH == NULL)
 {
 ReportResError(“GetResource(portResType,
 timePortResInfoID)”);
 }
 HLock((Handle) PortInfoH);
 PortInfoP = *PortInfoH;
 if (GetHandleSize((Handle) PortInfoH) != 0)
 {
 if (PortInfoP->timeBase.clientID != noClient)
 {
 TheErr = MIDIConnectTime(PortInfoP->
 timeBase.clientID, PortInfoP->
 timeBase.portID, arpClientID, timePortID);
 if (TheErr != midiVConnectErr)
 {
 
 MIDISetSync(ArpGlobals.TimeRefNum,
 midiExternalSync);
 }
 }
 
 for (i=0; i<PortInfoP->numConnects; i++)
 {
 MIDIConnectTime(arpClientID, timePortID,
 PortInfoP->cList.clientID,
 PortInfoP->cList.portID);
 }
 }
 HUnlock((Handle) PortInfoH);
 ReleaseResource((Handle) PortInfoH);
 ReportResError(“PatchPorts/ReleaseResource()”);
 
 PortInfoH = (MIDIPortInfoHdl)
 GetResource(portResType,inputPortResInfoID);
 if (PortInfoH == NULL)
 {
 ReportResError(“PatchPorts/GetResource()”);
 }
 HLock((Handle) PortInfoH);
 PortInfoP = *PortInfoH;
 if (GetHandleSize((Handle) PortInfoH) != 0)
 {
 for (i=0; i<PortInfoP->numConnects; i++)
 {
 MIDIConnectData(arpClientID, inputPortID,
 PortInfoP->cList.clientID,
 PortInfoP->cList.portID);
 }
 }
 HUnlock((Handle) PortInfoH);
 ReleaseResource((Handle) PortInfoH);
 ReportResError(“PatchPorts/GetResource()”);
 
 PortInfoH = (MIDIPortInfoHdl)
 GetResource(portResType, outputPortResInfoID);
 if (PortInfoH == NULL)
 {
 ReportResError(“PatchPorts/GetResource()”);
 }
 HLock((Handle) PortInfoH);
 PortInfoP = *PortInfoH;
 if (GetHandleSize((Handle) PortInfoH) != 0)
 {
 for(i=0; i<PortInfoP->numConnects; i++)
 {
 MIDIConnectData(arpClientID, outputPortID,
 PortInfoP->cList.clientID,
 PortInfoP->cList.portID);
 }
 }
 HUnlock((Handle) PortInfoH);
 ReleaseResource((Handle)  PortInfoH);
 ReportResError(“PatchPorts/ReleaseResource()”);
}

void SavePatch(OSType PortID, short PortInfoResID, char *PortInfoResName)
{
 Handle PortResH;
 CursHandle WatchCurs; 
 
 WatchCurs = GetCursor(watchCursor);
 HLock((Handle) WatchCurs);
 SetCursor(*WatchCurs);
 HUnlock((Handle) WatchCurs);

 PortResH = GetResource(portResType,
  PortInfoResID);
 ReportResError(“SavePatch/GetResource()”);
 RmveResource(PortResH);
 ReportResError(“SavePatch/RmveResource()
  (make sure disk is  unlocked)” );
 DisposHandle(PortResH);
 UpdateResFile(CurResFile());
 ReportResError(“SavePatch/UpdateResFile()
 (make sure disk is unlocked)”);
 
 PortResH = (Handle) MIDIGetPortInfo(
 arpClientID, PortID);
 
 addresource(PortResH, portResType, PortInfoResID,
  PortInfoResName);
 ReportResError(“SavePatch/addresource()”);
 WriteResource(PortResH);
 ReportResError(“SavePatch/WriteResource()
  (make sure disk is unlocked)”);
 UpdateResFile(CurResFile());
 ReportResError(“SavePatch/UpdateResFile()
 (make sure disk is unlocked)”);
 ReleaseResource(PortResH);
 ReportResError(“SavePatch/ReleaseResource()
 (make sure disk is unlocked)”);
 InitCursor();
}

void Terminate(void)
{
 MIDISignOut(arpClientID);
 StopDialog();
 ExitToShell();
}
6
http://macgui.com/downloads/?file_id=28070
Apple MIDI Manager 2.0.2
Apple MIDI Manager requires System 6.0 or later.
7
"supports S-series
Samplers, S2800, S3000, S3200 and CD3000, and XL-series Samplers, S2000,
S3000XL, S3200XL and CD3000XL."

supports all models of S2000/S2800/S3000/S3200
including XL models
13
http://downloads.mackie.com/drivers/digital_audio/
the driver files can be viewed and downloaded frm this location
including the v1.7 driver dated dec 2009
and the v1.9 driver dated july 2010

the v1.9 driver seems to be extended to supprt a taskbar application?

these drivers are for windows xp + Vista xp 32bit as far as i know
14
http://www.sonicstate.com/news/2009/07/31/mackie-cracks-the-digidesign-code/
https://www.sweetwater.com/insync/license-loud/
http://mackie.com/blog/loud-and-avid-announce-licensing-agreement (dec 2009)
https://web.archive.org/web/20091212003551/http://www.mackie.com/products/onyxiseries/
https://web.archive.org/web/20111228101210/http://www.mackie.com:80/products/onyx1620i
http://www.emusician.com/gear/1332/mackie-universal-driver-upgrade/43032
https://en.audiofanzine.com/firewire-usb-mlan-mixer/mackie/onyx-1220i/news/a.play,n.7177.html

driver was available from (Oct 2009) up untill about (Dec 2011) when it was removed from the product page for the onyx-i series mixers
link present in nov 2011: https://web.archive.org/web/20111127221407/http://www.mackie.com:80/products/onyx1620i/
link Removed in dec 2011: https://web.archive.org/web/20111228101210/http://www.mackie.com:80/products/onyx1620i
so we can confirm that support was revoked by digidesign at the end of 2011

https://www.prosoundweb.com/types/news/aes_news_mackie_qualifies_onyx_i_mixers_for_use_with_pro_tools_m_powered_8/

Quote
from April 1 to May 31, 2010, this driver will be absolutely free.  -- http://www.musicradar.com/news/tech/mackie-announces-free-driver-upgrade-242921

https://web.archive.org/web/20100409110439/http://www.mackie.com:80/enews/2010/04/free_pro_tools_m-powered_8_com.html

https://web.archive.org/web/20100419011732/http://www.mackie.com:80/


https://web.archive.org/web/*/http://downloads.mackie.com/drivers/digital_audio/*
https://web.archive.org/web/20091004092805/http://downloads.mackie.com/drivers/digital_audio/V1.5%20Driver%20and%20Release%20Notes.zip
http://downloads.mackie.com/drivers/digital_audio/V1.5 Driver and Release Notes.zip
https://web.archive.org/web/20091212063349/http://downloads.mackie.com/drivers/digital_audio/V1.7%20Driver%20and%20Release%20Notes.zip
https://web.archive.org/web/20100111203516/http://downloads.mackie.com/drivers/digital_audio/V1.7%20Driver%20and%20Release%20Notes.zip
http://downloads.mackie.com/drivers/digital_audio/V1.5 Driver and Release Notes.zip
https://web.archive.org/web/20101230183822/http://downloads.mackie.com/drivers/digital_audio/V1.9%20Mackie%20Universal%20Driver%20and%20Installation%20Instructions.zip

"Pro Tools® Users: The V1.9.0 driver does not support Pro Tools® M-PoweredTM 8 on Windows 7."
v1.1.0 - feb 2009

i think these files are only for the original onyx series that were upgraded to firewire compatibility via a firewire card sold seperately (upgrade)
https://web.archive.org/web/20110811151010/http://downloads.mackie.com/drivers/digital_audio/V1.1.0%20Driver%20and%20Release%20Notes.zip
https://web.archive.org/web/20140828174644/http://downloads.mackie.com:80/drivers/digital_audio/onyxi/
https://web.archive.org/web/20150129062200/http://downloads.mackie.com/drivers/digital_audio/V1.1.1%20Driver%20and%20Release%20Notes.zip

Supported Devices for v1.1.0 + v1.1.1 driver files:
Mackie Onyx FireWire Card (for Onyx 220, 620, and 640 mixers)
Mackie Onyx Satellite
Mackie U.420
Mackie U.420d Mackie d.2 Pro Mackie d.4 Pro TAPCO Link.FireWire

https://www.reddit.com/r/audioengineering/comments/3nnk06/anyone_having_any_luck_with_mackies_onyx_series/
15
heres the release dates for pro tools 9

date   version   notes
05/25/2011   9.0.3   
03/09/2011   9.0.2   
01/05/2011   9.0.1   
11/04/2010   9.0

apparently digidesign/avid sued mackie after pt9 came to market and allowed any + all interfaces to use pro tools
17
midi - Serial (MAC) 90s / Re: Opcode Studio 5 (Oct 1991) Networking
«  by chrisNova777 on November 21, 2017, 03:35:03 PM »
https://web.archive.org/web/19961018010101/http://motu.com:80/downloads/Extras/Studio5.FMS.sea.hqx
i found this mac archive document related to using the Opcode Studio 5 Interface with MOTU's FreeMIDI application
18
"a package that includes the Mackie Universal Driver (posted publicly) and Mackie Authorization Application (what im looking for!!!!!) ($49.99 USD) that unlocks your mixer for use with Pro Tools® M-Powered™ 8."

this dates back even to 2009!!!!
https://web.archive.org/web/20091212063349/http://www.mackie.com:80/products/onyxiseries/drivers
https://web.archive.org/web/20101204053830/http://www.mackie.com:80/products/onyx1620i/


and 2011
https://web.archive.org/web/20110713004507/http://www.mackie.com:80/enews/2010/11/mackie_offers_high-quality_fro.html

posted as of (Nov 2010)

Quote
MACKIE OFFERS HIGH-QUALITY FRONT END SOLUTIONS FOR PRO TOOLS 9

Great news! Mackie recording interfaces are now more compatible than ever before,

Unless you’ve been living under a rock the past week, you are likely aware of Avid’s latest Pro Tools announcement. Namely that their latest software release, Pro Tools 9, is now open to all interfaces that use ASIO or Core Audio drivers.

This is big news. Big, big news.

In addition to the wide breadth of DAW compatibility Mackie already offers, this means that you can also now plug any ASIO / Core Audio Mackie interface right into Pro Tools 9 and get straight to work. No longer are you obligated to use proprietary interfaces. Instead, you can use Mackie’s proven high-quality preamps and converters alongside user-friendly feature sets to bring your recordings to new level – and you can do it on your recording platform of choice.

Mackie is no stranger to working with a huge variety of DAWs, even Pro Tools. After all, we kicked our relationship off over a decade ago with HUI – the world’s first control surface to function with the world’s most popular DAW. Then, our popular Onyx-i Series mixers changed the face of the industry last year, being the first ever third party devices to work with Pro Tools M-Powered 8. We created the driver that let you work how you wanted and we are very proud of that. Of course, support for this combination will continue, but with the announcement of an open-ended Pro Tools platform, there is now a wide range of options that offer the high-quality preamps, converters and innovative features that set Mackie apart from the pack.

Blackjack-3qtr-R-reflected The new Onyx Blackjack 2x2 USB Recording Interface is the perfect desktop interface for your favorite DAW. Ultra-compact and featuring our renowned Onyx mic preamps and high-quality AD/DA converters, the Onyx Blackjack is a great option from simple home studio to rugged mobile recording.


 

Blackbird_front_slantNeed more inputs and expandability? The Onyx Blackbird 16x16 FireWire Recording Interface takes things a step further. Eight boutique Onyx preamps and expandability via ADAT and Word Clock offer deeper integration into an existing digital setup or a powerful start that grows along with your studio needs.

©Earl Harper Our flagship Onyx-i Series FireWire Production Mixers are unrivaled in the market, delivering the power, performance and FireWire flexibility needed for your main production console. In fact, the Onyx 1640i delivers something that no other mixer in this class can do: the ability to not only send 16 discrete inputs into your DAW, but to bring up to 16 signals right back into the channel strips for a true tape-style mixdown. Mackie Onyx-i mixers are unique, offering a tactile tracking and mixing solution with the state-of-the-art front end, premium EQ and AD/DA converters and FireWire routing possibilities you’ve been waiting for.

MCU-Pro-Alt3Qtr But the offerings do not stop there. Mackie’s powerful control surfaces, the MCU Pro and Extender Pro offer customizable, hands-on control over your DAW. The motorized faders and recallable v-pots offer tactile control that is nothing short of amazing. And if you are a Mac user, you can plug in our popular ProFX Series Compact Effects Mixers at your next gig and record the whole thing into PT9.

So, as you can see, Mackie recording interfaces are now more compatible than ever. Avid has certainly opened the door, letting you choose both the hardware the software that is right for you. Don’t waste this opportunity. Choose the audio interface that delivers industry-leading quality, sound and innovative features that make your life easier…all at a price you can afford.

For more information on Mackie recording interfaces including a list of compatible DAW software, visit www.mackie.com.

Posted by Mackie on November 11, 2010 11:55 AM | Permalink
19
synths - 2000s / Re: e-mu vintage pro (2002)
«  by chrisNova777 on November 20, 2017, 06:16:05 PM »
can anyone help me to confirm if the vintage pro soundset contains the same voices from teh vintage keys unit from 1994?

is it an updated soundset with the same sounds?
or not the same?