The following is a short overview of Cmix.  It is followed by a list of
manual pages to be read for more detail.  What follows is merely 
an attempt to describe the general shape of the environment.

Cmix is a simple package of routines which make it relatively easy to
create binaries which read and/or write digital signal files in 1,2
or 4 channels.  The 'soundfiles' can be in either 16-bit integer or
32-bit floating point form.  All sample data is specified internally
in 32-bit floating point form, and converted appropriately according
to the soundfile type.  The soundfiles have an IRCAM 1k header which
contains the sampling rate of the file, the number of channels,
possibly the peak amplitude for each channel, and the location of that
peak, the type of word stored (f or i), and an optional comment if 
desired.  Cmix was built around BSD systems and has run on various Vaxen
and Suns with little difficulty.  It depends on being able to write files
with 'holes' and of arbitrary size.  We have no experience with sys V
at this point, although it was hacked to run crudely on a MacII.

To build the Cmix tools there are only three binary files which have
to be created.  The first is ..cmix/Minc/m.o, which takes care of
reading user data (instrument arguments), ../cmix/cmix.o, which 
contains most of the i/o routines and a library, ../cmix/genlib.a
which contains a number of 'unit generators' in the old Music-4, music-5
sense.

Then to actually build a Cmix-based application, the user writes a 
C program with a given name, writes a profile file, which introduces
that name to Cmix, and links his program and profile, with cmix.o.
(m.o is joined with cmix.o when the latter is built), searching
genlib.a for any unit generators needed.  A given application can
invoke a large number of programs, as long as they were introduced
properly.

To run that application, the user invokes the executable, and reads
data to the instrument from the standard-input or from a file.
In general (although not necessarily) the application will simultaneously
read and/or write samples, and issue reports to the standard output.
The 'instrument' data is specified in a front-end called Minc which enables
the user to use C-like syntax (but not quite), loops, variables, 
arithmetic expressions etc.  

Up to four soundfiles may be read or written simultaneously.

Also provided with this distribution are a number of utilities to
tinker with headers, looks at samples, and store files on tape.
We have some extensive linear prediction programs but these are not
yet ready for general unattended distribution.  There is also an
extensive Cmix based soundfile mixing and editing program.

Cmix differs from classical synthesis environments such as Music4,5,10,11,
360, etc in that it has no scheduler.  Each 'instrument' has random
access to the whole soundfile and completes its business before giving
up the stage to the next instrument or note.  It may 'mix' its output to 
what is already on the disk, or it may write over what is there.  The choice 
is left up to the user and the application. The result of this approach
is much more i/o than the Music4,etc. type programs.  In Music4-type programs
every instrument playing on sample n, must be computed for sample n, before
sample n is written to disk.  The Cmix approach is more akin to a rehearsal
in which each instrument is rehearsed separately and then mixed together.
(It should be remembered that the Music4-type programs were written at a 
time when disk storage was so limited that it was expected that the output 
was written on tape.  As a matter of fact my first jobs back in 1966 were 
written only on tape--using IBM 7094).  I don't think they even had a disk.  
There was some sort of drum device.)
But the loss of efficiency caused by the increase of i/o is compensated
for partially by the greatly reduced overhead.  

The other difference in approach is that much more programming is expected
of the user and consequently this program is probably best used in 
conjunction with MIT's Csound which is much friendlier, but ultimately
probably less extensible (at least by those who don't understand its
intimate innards.)

We have number of Cmix-based applications (lpc, room-simulation, filtering,
etc., -- we have also imbedded the UCSD phase-vocoder in CMIX --).  When 
you have the essential program running, and understand how to use it, let
us know and we can send you more of these applications.

Thanks to the following for their contributions: Romain Kang, Lars Graf,
Brad Garton, Andy Milburn, Dave Madole, Charlie Sullivan.

Paul Lansky (2/88)


Read the following manual pages in the approximate following order:

intro	---- brief look at data specification format.
usersub ---- introduction to format of user-written subroutines.
profile ---- how to introduce user-written programs to cmix.
open	---- open soundfile for reading and/or writing.
setnote ---- position pointer on output or input file.
endnote ---- closing and updating an output soundfile.
io	---- user-controlled flavors of disk i/o.
Minc	---- a description of the data specification language for Cmix.
cmix	---- a description of the global commands available in Minc.
makegen ---- draw and store function.
fsize	---- sizing a storage array.
floc	---- locating a storage array.
genlib	---- a description of the library of unit-generators.
sfheader---- description of header structure.
sfcodes ---- description of header structure.
sfhedit ---- edit a soundfile header.
sfcreate---- create a soundfile header.
mix	---- description of Cmix based mixing and editing program.
tapeman ---- storing and retrieving soundfiles from tape.
lsf	---- get stats on soundfile.
hist	---- draw amplitude and frequency plots of a soundfile.

More useful information:

getsample -- how to fetch an arbitrary sample from a soundfile.
rescale ---- convert file to playable 16-bit integer form.
fplot	---- drawing simple plots of functions.
setline ---- draw arbitrary curve.
sfextend---- extend the length of a file (creating a hole).
sfprint ---- print a soundfile header.
sfshrink---- shrink (release part of) a soundfile.
sndpeak ---- find the peak amplitude of a soundfile.
table   ---- table lookup function.
tempo	---- set tempo.