For specific features questions about the plugin architecture, visit the Plugins FAQ.
What does 'CPS' stand for?
In the computer music world, CPS means 'cycles per second', or: Hertz.
But CPS means what you think that it means, as long as it sounds positive.
Originally, it was just a random work name of a project, but the name survived through the years.
Is CPS based on C-sound / Can I use C-sound inside CPS?
CPS is not based on C-sound but most core objects are implemented using the
MPEG-4 Structured Audio
standard (edited by Eric D. Scheirer), which, on its turn, is based on C-sound.
So a lot of objects look a lot like Csound. A more
detailed description of where CPS comes from, can be read in the manual.
You can easily run Csound as a VST plugin inside CPS, thanks to the
CsoundVST plugin by Michael Gogins (download the
most recent version or an
Is CPS dead?
Well, yes and no. Yes as in: it's not being enhanced every day anymore, like it was in the first six years
of it's existance. So big changes do happen but only if it is necessary for a certain nice external project,
or if it really seems needed by enough customers. On the other hand, CPS is not dead. New versions
and bugfixes do appear, but not so often anymore. And if you e-mail the helpdesk, you will surely get
an answer the same day or at least within reasonable time. If the thing where you mailed about is a bug,
then there's a big change that you receive the bugfix together with your answer.
Is the CPS file format compatible with Opcode Systems/IRCAM MAX's?
No, it isn't. CPS has got nothing to do with MAX, so nothing is compatible with MAX
(or MAX/MSP or jMax or Pd).
The objects from CPS differ significantly from MAX/MSP: several objects in MAX/MSP are
in only one object in CPS (like 'switch'), most (control) objects in CPS are created
according to ANSI C++ or LISP, and most (audio) objects in CPS are created according
to the MPEG-4 Structured Audio (SAOL) standard.
Because CPS is very new and created using the modern tools and concepts that exist today,
it has a cleaner design in usage and cleaner concepts in general than MAX, although
exists much longer it has more advanced tricks in user design and also a bigger user base
than CPS. There are some relationships however; the event-drivenness of MAX,
is also present in CPS. Also, nearly the same things are possible with CPS as in MAX/MSP.
This question is so frequently asked, that here is a small list of the most important
- complete assign/evaluate distinction (for example the '+' object has three inputs: left argument, right argument, and 'evaluate') which leads to less bugs and no need for a special 'bang' signal.
- subpatches and inlets/outlets are 100% simulated, so if you have things in a subpatch, it runs exactly as fast as when everything was created inside one huge patch.
- tables are for k-rate usage and for a-rate usage - also, table has 'generators' to fill it with a small formula (like envelopes or windows or soundfiles).
- no l-t-r graphic distinction but a seperate object to control the order (called 'order'), which leads to less bugs during patchmaking and especially a lot of less head-scratching
- objects have multiple appearances (polymorfal) instead of having more objects which do the same (for example '+' has about 20 shapes for as well k-rate as a-rate as tables).
- error detection: VISUAL feedback of when an error occurs (the object which generated the runtime error changes from color, for example when dividing by zero), and infinite loop detection instead of crashing
- not multiple signals (integer float text etc.), but more inputs if there are more options
- less signals: no text or lists supported - may sound as a missing feature, but up till now not needed at all because you can't build graphical interfaces with CPS. If there are any options which need text, there are simply numbers which represent these options. There is text support for options of objects seperately (so not as a signal but to objects directly, for example a list of filenames of the audioFromDisk object).
If you are interested in differences between CPS and MAX/MSP, then you can read the whole
manual. It will get clear to you that there are really a lot of
Can I make a stand-alone program of a patch?
Yes, you can. You do not have the graphical interface of CPS within your
program, but the 'engine' of CPS runs stand alone. You can use the engine
inside a C++ or Java program or in MacroMedia Director/Shockwave.
Use one of these three to make a graphical interface for your program.
To get you started, you can save a patch as C++ or Java or
Lingo (for MacroMedia Director) code.
There is also a usefull object (called 'application') to test a CPS patch inside your
application, so that the graphical interface of CPS is still available.
See the documentation of the 'application' object for more information.
Does CPS have text editing facilities?
Currently not. This does not seem to be a missing issue in CPS, simply because arguments (including text) is given often by doubleclicking on an object and giving text-arguments
there. The control inputs are then used to give commands to the object (simply instead of readable text commands) or to switch from arguments. In standAlone mode, you can use text and feed these text-arguments directly into
the objects. Registered Users: if you look carefully to the plugin format, you can see that there is actually already support for textual exchange in the plugin format.
Can I use MPEG-2 Layer 3 audio files in CPS?
Yes you can. You can use .mp3 files in your patch at every place where you can also use a
.wav file: 'audioFromDisk' and 'table'.
With what precision are the calculations done in CPS?
All objects work with 32-bit floating point precision (there is no
special support for integers on controlrate, everything is floating point).
This is also prescribed by the MPEG-4 Structured Audio standard.
Can I use CPS in a browser?
Yes you can (though not with the shareware version).
Save your CPS-patch as Director/Shockwave lingo code and insert it inside
your Director/Shockwave project. Click 'File'-'Publish', and you are done!
Clients can download the CPS2Browser add-on on
the CPS website.
Another way to use CPS in a browser is to use the save as .java feature, but then
you need to use signed applets.
Why doesn't have every object an example patch as help instead of a helptext?
Because hardware objects are 'unique' in CPS. You cannot have two midiIn or audioOut
objects that are in reality the same hardware device. This would mean that every example
would just be
a subpatch that you have to connect in the right way yourself! Of course, an example that
doesn't work immediately, can never be a good example.
So, instead of introducing 'global' (or: not unique) objects, which can
be confusing and unconsistently because of the 'hidden wiring' that has to be done, a
helptext is provided, and examples are seperately included with the program.
Also, if you are (as developer of plugins) forced to make a helptext, it's less easy
to forget some very obvious
things about the object, which are often left-out accidently in example-patches.
Can CPS save patches as SAOL files (in future)?
Currently CPS can not save patches as SAOL (MPEG-4 Structured Audio Orchestra Language)
At the time when CPS was developed, MPEG-4 Structured Audio (also known as SAOL) was in
development, and it looked
like it was becoming the standard of the future. There was even a buzz about hardware
implementation. Now it seems like the structured audio is one of few the parts of MPEG-4
that are not implemented in MPEG-4 compliant software and hardware implementations.
This is probably
because there are several unrealistic and unclear things about it as a standard,
for example: the filters are not defined but are free to implement by the
decoder (so there is not one unique decoder!!!), some opcodes were not even implemented
in the reference implementation ('reverb', 'chorus', 'flange', etc - which makes it even
harder to make a unique decoder), some opcodes
(in the reference implementation) were really poor and actually unusable (like
'compressor'), and there is obligated sample-precision audio (instead of buffered audio,
like _ALL_ software works today).
On the other hand, these are all really bad things for a standard to become one.
But to actually use it, there's no problem at all!! In CPS, filters are just
implemented, not-implemented opcodes are implemented, the bad opcodes are present
(but probably not used), and (to be complete) the sample-precision is replaced by
buffered audio and local-only sample-precision (which makes it realtime even on slow systems).
Notice that the core opcodes/objects of MPEG4-SA are perfect, because the concepts
behind them are 100% derived from Csound (which exists over 30 years now).
So, alltogether it is a perfect base for a new sound environment like CPS.
Except some interesting research tools, there are no MPEG4-SA implementions, so for now,
there is no 'save as .saol' support. If several MPEG4-SA implementations appear, then this
feature will be implemented (as well as a 'save as .orc' since both formats look alike).
Some more details. Implementing 'save as .saol' has some more problems than simply converting the file format
to a .saol file. For example, CPS has an event-driven rate, SAOL (and Csound) hasn't. This
rate has to be simulated completely, which is a big job to do. Furthermore, SAOL 's instruments
and macro's do not support controlrate OUTPUTS. CPS it's subpatches do have controlrate
outputs. This means that any subpatch (macro's are subpatches) has to be de-subpatched and
then transcribed as SAOL code. This is even more work to do, only because SAOL does not
support it. It means that every CPS patch would result in an unreadable (but working)
piece of saol code. As long as there are no serious tools out there that can actually do
something interesting with the resulting .saol code, it has no use at all to put
months of expensive development time into this feature. It does sound appealing to have
as a feature, but in reality it has no advantages.