From MusE Wiki

To give you a brief overview about what you can or could do with MusE so far.

Contents 1 Environment To Run MusE In 2 Mixer (Line In/Out) 3 Arranger, edit capabilities: Copy&Paste 4 MIDI controller abstraction with idf 5 Virtual Synthesizers 5.1 M.E.S.S virtual synth format 5.2 VST/Instruments (Windows binaries) 5.3 Virtual Synthesizers running outside of MusE 6 Supported Hardware 6.1 PCI (Peripheral Component Interconnect) 6.2 Soundcards USB (Universal Serial Bus) 6.3 Midihubs using USB 6.4 SERIAL (Serial Interfaces Which Some Synthesizers Use) 6.5 FIREWIRE 6.6 LAPTOP (Soundcards Build Into Laptops) 6.7 Multiple Soundcards (Midi/Wave) 7 Create your own softsynth with M.E.S.S 8 Internal Storage Format 9 Written Completely In C++ / QT 10 Success Stories 11 Interested? Got More Questions?

Environment To Run MusE In

MusE + virtual synthesizers + real synthesizers.

http://muse.serverkommune.de/pic/muse_screenshot2_s.jpg

With MusE you can trigger many common MIDI signals on real external synthesizers via MIDI. With 0.7.x the sync out/in is not implemented but our goal is to get this done in the final 1.0 release. To not forget there are also the internal so called software synthesizers which can be used together with MusE. For example the the MusE bildin fluidsynth playing soundfonts in. To enhance you creativity, MusE can also be used as a multitrack recording studio for analog audio recordings.

NOTE: MusE is a linux application and does NOT run on Windows nor on any MAC os X version.

Linux Kernel 2.6, 2.4 preemtive,LSM,... (more to come Realtime)

http://www.tldp.org/HOWTO/MIDI-HOWTO-8.html

Mixer (Line In/Out)

MusE has a built in mixer that in one convenient window allows for mixing both midi and audio.

http://www.muse-sequencer.org/pic/wiki/Mixer.jpg

• LADSPA Plugin architecture
  With this high qualitiy plugin architecture you can get much more out of your recordings! 4 insert effects on every audio channel plus the ability to share an unlimited amount of send effects between all audio channels will give you many artistic possibilities.
• Mixer automation
  You can record changes of e.g. volume of all individual tracks during the song, this will then be played back exactly as recorded during playback.
• JACK integration
  The integration with JACK goes straight into the mixer, which makes it very easy and flexible to connect MusE to other JACK applications. Outputs from other JACK applications, plus the abilitiy to create several outputs straight into/from the mixer makes integration with other applications a breeze.
• Enhanced mixer automation (0.8 current CVS) with parameter curves!
  With the 0.8 version (which is in the early alpha state now -> CVS ) a very new and innovative controller handling (controller curves) will be introduced. You can set points in the arranger which will be interpolated by lines from which then the controller values will be computed. The big advantage not only the volume of a track can be controlled very individually even every controller like cutoff, velocity, pitch, ... can be controlled like this!

Arranger, edit capabilities: Copy&Paste

The arranger, the most important element of a sequencer contains these editors:

• Piano Roll
  You are not bound to a certain amount of open windows of a track! So you can watchout on several parts of the song and compare them with two piano roll editors viewing the same part.

http://www.muse-sequencer.org/pic/wiki/pianoroll.jpg

• Drum
  There is a special drum editor. You can set a note with one click and it's easy to assign diffrent midi outputs and midi channels per note-key. Also the controller editor lets you easily assign the pitch of every marked note so you can create percussive patterns easy.

http://www.muse-sequencer.org/pic/wiki/drumedit.jpg

• List
  Here you can add things like controller values (CC) or program changes (PC) in a certain position of the song. Also you can change every element which is used in MusE together with MIDI. You can delete and insert sysex commands quite fast!

MIDI controller abstraction with idf

If you use expanders like the "Roland XV 3080" you can select sounds and controllers within MusE. In a few steps you can build your own library of your own soundbanks and controllers. In case this has not yet been done for your special synthesizer just write it youself, it's quite easy.

Here an example of how it could look like (XML syntax):

<?xml version="1.0"?>
<muse version="1.0">
 <MidiInstrument name="MC307">
    <PatchGroup name="Bank 01 Piano">
         <Patch name="64voicepiano"   hbank="64" lbank="0"  prog="0"/>
         <Patch name="Lead TB 2"   hbank="65" lbank="0"  prog="0"/>
         <Patch name="Wow TB"   hbank="66" lbank="0"  prog="0"/>
    </PatchGroup>
 </MidiInstrument>
</muse>

Virtual Synthesizers

MusE supports the use of virtual synths. Both external formats connected through Jack and several synth types that are connected internally. Connecting synths internally give the added benefit that all connectivity and patch handling is automatically taken care of.

M.E.S.S virtual synth format

MusE's own internal synth format is M.E.S.S. Several synths are currently implemented for M.E.S.S. Below is a picture of MusE's version of Fluidsynth:

http://www.muse-sequencer.org/pic/wiki/Fluidsyntgui.jpg

VST/Instruments (Windows binaries)

First of all MusE can connect to make use of VSTi and not to VST plugins(this is coming in v0.8) for audio processing. What VSTi plugins are supported so far you can find out here:

http://www.djcj.org/LAU/ladspavst/

You have to use WINE and the setup is usually not easy.

Virtual Synthesizers running outside of MusE

Apart from the internal synths you can run software synths outside of MusE and connect them through ALSA and JACK so they also are fully integrated.

Some remarkable synths include:

• ZynAddSubFx http://zynaddsubfx.sourceforge.net/
• Hydrogen http://hydrogen.sourceforge.net/?p=features
• AMS (Alsa Modular Synth) http://alsamodular.sourceforge.net/
• aeolus http://users.skynet.be/solaris/linuxaudio/
• .... many more

Some remarkable samplers:

• linuxsampler http://www.linuxsampler.org/
• .... many more

You can check the list of supported JACK applications here: http://jackit.sourceforge.net/apps/

Supported Hardware

This list is just a hint of what works, it's not' the complete truth Hardware drivers are improved all the time so this list will get outdated!
As of November 2004 it is quite close to the market.

You should also read on here:
Dave Phillips's Linux Sound page

Here's a list of cards which were reported to be working according to it's vendors. But don't buy a card because it's in the list below! Doublecheck it with a google search or the ALSA homepage.

PCI (Peripheral Component Interconnect)

If we would recommend a brand it would probably be RME. This is because they support linux and help to create good quality drivers supporting all the features of their cards. But even a more valuable benefit is that these cards are high quality audio devices usually equipped with very good DA and AD converters.

• RME Hammerfall read more
  • RME-Audio DIGI96/8 PAD
  • RME Hammerfall and Hammerfall DSP interfaces (PCI and cardbus versions)
  • Digi32, Digi32/8 and Digi32 Pro.
  • Digi96, Digi96/8, Digi96/8 PRO, PST and PAD.

• M-Audio: I've heard that the M-Audio Delta Audiophile 2496 is a popular choice but it's not that "cheap"?
  • DMAN PCI.
  • Delta 44, 66, 410, 1010 and 1010LT.
  • Audiophile 2496.
  • Delta DiO 2448 and 2496.
  • USB Audio Duo, Quattro and Omni Studio.
  • USB Keystations.
  • USB Midisport 1x1, 2x2, 4x4 and 8x8.
  • All Midiman Delta interfaces (66, 1010, etc)!!
• Most AudioScience cards
• The Soundblaster Extigy and Audigy
• Echo Darla24, Gina24, Layla24, Mia, and Mona
• Gadget Labs interfaces
• All Roland/Edirol USB interfaces
• Most Terratec interfaces
• Most Yamaha USB interfaces
• Mark Of The Unicorn
  • Micro Express.
  • Midi Express XT.
  • Midi Time Piece AV.
• Roland/Edirol
  • PC300.
  • SC8820 and SC8850.
  • SCD70.
  • SD20, SD80 and SD90.
  • SK500.
  • U8.
  • UA1A, UA100, UA100G and UA700.
  • UM1, UM1S, UM2(E), UM4/Super MPU64, UM550 and UM880.
  • XV5050.

• Turtle Beach
  • Daytona.
  • Malibu.
  • Montego II.
  • Tropez and Tropez Plus.

Soundcards USB (Universal Serial Bus)

• tuscam usb interface
• MK-425C USB read more

Maybe this link can bring even more light in the dark:
http://www.iptel-now.de/HOWTO/USB/usb.html

Midihubs using USB

MAudio USB Midisport 1x1, 2x2, 4x4 and 8x8.

SERIAL (Serial Interfaces Which Some Synthesizers Use)

For example the "Korg NS5R Midi Expander" is connected to the serial driver.

The Korg has three Ports:

• port-A connects to the first internal synthesizer
• port-B connects to the second internal synthesizer
• port-Ext connects to the external midi connector of the NS5R

FIREWIRE

You should read on here. I think most device drivers are in an early alpha stage and won't be useable for use yet.

• ESI QuataFire 610
• M-Audio Firewire Audiophile
• M-Audio Firewire 410
• M-Audio Firewire 1814
• Terratec Aureon 7.1 FireWire
• Edirol FA-101

LAPTOP (Soundcards Build Into Laptops)

• Almost all builtin audio interfaces for laptops and desktop systems, including those from Intel, Via and SiS (note: these do not generally provide particularly good audio quality, and in some cases are very poor).

This is just a small selection of soundcards and other hardware supported by ALSA. Some drivers have been available in stable versions for a long time, while others are still in development.

Most USB devices are supported, as long as they are standards-compliant. For a full list, read this.

This list is FAR from beeing complete and FAR from being correct and proved!

Multiple Soundcards (Midi/Wave)

With MusE >= 0.7.x you are not bound to a single soundcard - thanks to ALSA and the MusE architecture you can use 2 or even more of them. This increases connectivity and a soundcard costs much less compared to a MIDI interface!

Several soundcards for total MIDI control! Compared to modern studio soundcards as the "RMS Hammerfall" or "M Audio 1010" the quality of cheap cards is a criteria for a good production. But using these cards as MIDI devices only will result in a clear structured song creation.

Create your own softsynth with M.E.S.S

M.E.S.S. stands for MusE Experimental Soft Synth and is an API/interface (like DSSI) to enable programmers to easily create their own softsynths. The interface for a M.E.S.S.-synth consists of two classes, the Mess and Messgui. In short, the framework provides the Mess (the synth) midi data (notes, controllers and sysexes) and methods that handle the IPC between the gui and the synth, so the programmer can focus on DSP-issues instead.

This is a short description of the methods in the virtual Mess-class, defined in mess.h:

virtual void process(float** data, int offset, int len) = 0;

This is where the audio processing takes place. The Mess is called with a float array, and it's up to the programmer to fill it with data beginnig at data[offset] to data[offset+len]. There are two ways to go when it comes to how midi data is fed into the Mess. You can either

• implement processEvent
• implement one or more of the methods setController, playNote and sysex

If you choose to implement processEvent, it's up to yourself to decide which kind of midievent you're receiving and treat it accordingly.

virtual bool processEvent(const MidiPlayEvent&);

If you choose to go the other way, setController is where the Mess gets the controller events from the sequencer. playNote is where notes are fed to the Mess, and sysex, well, you get the picture...

virtual bool setController(int, int, int) { return false; }

virtual bool playNote(int, int, int) { return false; }

virtual bool sysex(int, const unsigned char*) { return false; }

getInitData is called when a song (project) is saved, and this is where you create the data which will recreate the synths current state when the project is reopened.

virtual void getInitData(int*, const unsigned char**) const {}

getControllerInfo is called on when the Mess is instantiated, and this is where you tell MusE which controllers the Mess supports. Just fill in the values and return the index you want to be sent next time. Return 0 when you've given MusE information about all controllers.

virtual int getControllerInfo(int index, const char** name, int* controller, int* min, int* max) const

hasGui is called when the Mess is instantiated, and tells MusE if the synth has a gui or not.

virtual bool hasGui() const;

showGui is called from MusE when the gui is supposed to be visible.

virtual void showGui(bool show);

getPatchName and getPatchInfo are used to give MusE information about patches, which can be selected in the track inspector.

virtual const char* SimpleSynth::getPatchName(int , int, int) const

virtual const MidiPatch* getPatchInfo(int arg1, const MidiPatch* arg2) const;

For the Gui, there's really only one method that is interesting:

virtual void processEvent(const MidiPlayEvent&) {};

processEvent in the gui is called whenever the synth sends it a midiEvent. (send(MidiEvent&)). Since this is the only method The gui can send midimessages to the synth via sendEvent, sendController and sendSysex calls. Oh, there are two more things, you need to provide a static instantiate-method and a mess-descriptor. These look something like this:

static Mess* instantiate(int sr, QWidget*, const char* name)

{

printf("SimpleSynth sampleRate %d\n", sr);

SimpleSynth* synth = new SimpleSynth(sr);

if (!synth->init(name)) {

delete synth;

synth = 0;

}

return synth;

}

extern "C"

{

static MESS descriptor = {

"SimpleSynth",

"Mathias Lundgren (lunar_shuttle@users.sf.net)",

"0.1", //Version string

MESS_MAJOR_VERSION, MESS_MINOR_VERSION,

instantiate,

};

const MESS* mess_descriptor() { return &descriptor; }

}

Now you're all set and done, it wasn't worse than that. Check out the code for other synths to get an even better idea of what's happening behind the scenes, and how other developes have solved their problems.

Internal Storage Format

All configuration files, as for example your MusE configuration, are stored in an XML format. XML itself is a very handy format compared to the binary format we used in 0.6.3 which now is a problem: backward compatibility. Nobody has the time to write a import filter for the 0.7.0 format so users who still have 0.6.3 MusE project files have to wait until such a filter is created.

Written Completely In C++ / QT

This is along any Open Source project a major point because you can access the source of the program and in case you need it you can change things as you wish. MusE is licensed completely under the terms of the GPL.

Also the use of C++ in conjunction with QT gives you many advantage as for example a common look with your daily desktop environment. The file dialogs look nearly the same and even some standard buttons look the same.

Success Stories

Several people are using MusE more or less regularily to create music (see the HallofFame for some public examples.)

Some user comments:
- Joachim
MusE 0.7.0 has already been used as multi track recorder to record several songs. Also to master them and apply effects to certain tracks. In some sessions MusE was such stable that it didn't crash for 4 hours of recording and playback. As always there are still some problems left - but non which can't be handled.

- Robert (Spamatica)
Using MusE on a regular basis to do anything from short audio recordings to complete arrangements with audio, midi, softsynths, etc. Since 0.7 it's stable enough for me to complete lots of songs without any major hassle. There are still features missing to make it "complete", most of these are slated for inclusion in 0.8 though =).

Interested? Got More Questions?

Read the Faq if you have more questions. If you want to give MusE a try then you should probably read on here Download.