Igevorse Otonnoleare

Here're good news about MuseScore!

I finished implementation of two features:

• Assigning MIDI channels to instruments (PR 2126)
• MIDI Machine Control (PR 2128)

This is a part of my work in Google Summer of Code 2015.

"Assigning MIDI channels to instruments" allows to assign any MIDI port/channel to an instrument in Mixer.

New opportunities unlocked:

• Assign each instrument to a different MIDI port and connect MuseScore to external synthesizers, effects processor and VST instruments via JACK with minimum additional software (JACK + MuseScore + QJackCtl/any patchbay).
• Export MIDI mapping to MusicXML and MIDI files to make futher editing/processing simpler.
• Better control of MuseScore output for research/related projects (MuseScoreSSMN, etc).

MIDI Machine Control (MMC) is a feature that helps to control playback of MuseScore via MIDI by sending special MIDI messages.

New opportunities unlocked:

• Synchronize MuseScore with software that doesn't support JACK Transport.
• Control playback of MuseScore even without JACK.

Supported events:

1. System realtime messages:
   • Start (0xFA)
   • Stop (0XFC)
   • Continue (0xFB)
   • Song Position Pointer (SPP) (0xF2)
2. System exclusive (SysEx) messages: (0xF0 0x7F [deviceID] 0x06 [command] 0xF7)
   • Stop (command: 1)
   • Pause (9)
   • Play (2)
   • Deferred play (3)
   • Rewind (5)
   • Goto/Locate (0xF0 0x7F [deviceID] 0x06 0x44 0x06 0x01 [hr] [mn] [sc] [fr] [ff] 0xF7)

These features are not merged, so welcome for testing!

---

I'll start to work on "MIDI Actions" feature in a few days.

With this feature we will be able to change parameters/settings of external VST's via MIDI, it will be possible to create scores with more dynamic sound: musicians will be able to change chorus and pan dynamically, add portamento, sostenuto effects, and also use special MIDI events for changing parameters of external synthesizers/VSTs on the fly!

You can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features in MuseScore that you need and want.

This summer I participate Google Summer of Code at Portland State University.

My project title is "Improving sound in MuseScore scorewriter up to the level of commercial software".

I have two goals to implement:

• Assigning MIDI port/channel to instruments.
• MIDI Actions: sending arbitrary MIDI events from any part of score.

I started to work on the first feature last summer when I had a free time after GSoC 2014 and I've done a working prototype. Unfortunately, I had a lack of free time and a high load at university, so now I have a chance to finish it.

---

I work on my project for several weeks and I already have something to share.

I've done a significant work on "Assigning MIDI channels to instruments" feature and implemented bend playback. This feature wasn't mentioned in my GSoC proposal, but it matches my GSoC title well.

MuseScore had tools for creating different kinds of bends, but it wasn't able to play them: bended note was sounding like an ordinary one. Bend playback was implemented a long time ago, but then something was changed in MuseScore and bend playback was broken.

So, for many years people were asking for this feature, and now it's implemented!

Here's a video demo of bend playback: a solo from Guns N' Roses - Sweet Child O' Mine.

Now we have:

• bend playback via internal and external (via JACK) synthesizer.
• import bends from gp* files.
• export bends to midi files.
• "Export RPNs" checkbox in Preferences window that allows export of RPN events (some software crashes while getting RPN events).

You can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features in MuseScore that you need and want.

Eventually I've implemented automatic control over JACK/ALSA MIDI Out ports (see PR 1171).

This feature allows MuseScore to determine how many JACK MIDI and ALSA MIDI ports it should have and automatically add/remove ports when needed.

I used "lazy" approach to prevent flooding to JACK/ALSA with a lot of API calls: we add new ports only if we really need to do it (e.g. when opening a score with a lot of staves OR when adding a new instrument).

Example: If we have several scores opened with 1, 3 and 2 midi ports, we'll have 3 midi out ports even if we switch between scores (would not change from 1 to 3 and 2).

Recomputing number of midi ports is also optimized: we don't need to do an extra loop every second/tick/etc.

I started implementing this feature while participating GSoC 2014. I also wrote about this feature in my previous posts.

Hi!

In previous post I wrote a list of features I've implemented in MuseScore this summer. Now I made a demo of using MuseScore with VST instruments via JACK:

Yngwie Malmsteen - Far Beyond The Sun

Connections & Tracks

Connections in patchbay (clickable):

1. Lead Guitar

   I used Suburban Guitarist for synthesizing clean guitar sound and then added a bit of distortion with Guitar Rig 5. Used preset: Solo Maker.

2. Rhythm Guitar

   DSK Guitars Acoustic produced nice sound for the rhythm. Guitar Rig 5 with "Boosted Solo Metal" preset made dirty sound from that.

3. Bass Guitar

   I used simple DSK BassZ plugin.

4. Church Organ

   I've pre-recorded an organ staff using Church Organ 2nd VST(i) to demonstrate you using JACK Transport. I loaded this track into Ardour 3, and as you can see it started playing with MuseScore at the same time.

5. Drums

   Superior drummer is a well-known plugin for the musicians. I used Rock Solid preset.

VSTs are runned by FeSTige, final mixing is done with jack_mixer.

Software

MuseScore 2.0

jack2 1.9.10

Ardour 3

Catia 0.8.1

FeSTige 1.0.2

I recorded this video with SimpleScreenRecorder and edited with Kdenlive.

Used VST(i)

Suburban Guitarist

DSK Guitars Acoustic

DSK BassZ

Church Organ 2nd

Guitar Rig 5

Superior Drummer

Do you like it?

Hi!

I want to say thanks to my mentor Nicolas Froment (lasconic) and MuseScore community for the help and answering questions. Thank you for your contributing and evolving MuseScore, it is a great project! Also thanks to Google, due to GSoC I made my first contributing steps in the world of opensource.

It was a long journey to the world of code, it was very interesting and fascinating to dive into unknown code, to make a research in unknown areas, to invent new approaches and to create something new. New code, new features, new possibilities and new happy users. Sometimes new bugs too .

I hope my work was useful for the community, developers, users and the future of the project.

What I've done

Here is a list of features I've implemented while participating the GSoC 2014:

1. JACK MIDI Out support (PR)

   This feature gives an ability to send MIDI events to one or several external synthesizers or VST plugins.

   Profits:

   • More realistic sound of score.
   • Adding realtime midi effects to the sound.
2. JACK Transport (reposition) (PR)

   We provide current position in frames (samples) to JACK Transport, keep an eye on it and seek if position changed.

   Profits:

   • Seeking to some position in MuseScore causes seeking in all applications (audio/video players, DAWs, etc).
   • Seeking in any application connected to JACK causes MuseScore to seek.
3. JACK Timebase Master (commit)

   Being the Timebase Master application could provide bar (measure), beat and tempo information to JACK.

   Profits:

   • Sync other applications working with midi to MuseScore, managing tempo.
   • More control over JACK Transport (not just seek, but slow down/accelerate).
4. JACK Timebase Slave (commit)

   As a Timebase Slave we can read information about bar, beat and tempo and sync to any application connected to JACK as a Timebase Master.

   Profits:

   • More control over syncing to another application.
   • Adjusting tempo in real time to application / external automation tracks.
5. Changing JACK preferences without restart (commit)

   This feature gives an ability to enable/disable JACK parameters like "Use JACK MIDI Out", "use JACK Audio" or "Become a Timebase Master" without restarting an application.

   Profits:

   • No need to restart MuseScore if you want change preferences related to JACK.
6. Restoring JACK connections (commit)

   Now we can save audio and midi connections to other applications on exit or changing preferences and restore it when you run MuseScore again.

   Profits:

   • You don't need to connect all things again manually.
7. Automatic control over JACK/ALSA MIDI Out ports (Upd Nov, 29: merged) (PR)

   This feature allows MuseScore to determine how many JACK MIDI and ALSA MIDI ports it should have and automatically add/remove ports when needed.

   Profits:

   • No need to manually control port number.
   • One more step to implementing ALSA MIDI.
8. Assigning channels to instruments (not merged) (PR)

   With this feature users can assign any midi port and channel to instruments.

   Profits:

   • Channel information wouldn't be lost if you add new instrument, reorder staves or change midi program.
   • Better control over midi subsystem (you can even assign different ports for each instrument).
   • Ability to "compress" number of channels by assigning the same channel for a several, for example, piano staves.
   • Enhanced abilities to import and export scores (implemented import channels from *.ove, *.gtp*, import/export to *.mcsx, *.mscz, *.midi, *.mxl).
9. Improved Instument Change element (not merged) (PR)

   Several Instrument Change elements with one midi program are "joined" together and shown as a single item in mixer.

   Profits:

   • No excess items in mixer (particularly important for big and complex scores).

Also, there were a lot of bug fixes, related and not related to JACK, improvements of UI, code optimisations and other things.

What's next

I have to test the last two features in the list and fix the bugs. Also, I promised in my blog to improve MIDI Actions, so I have to implement it too. The bad news is that I have a little time: my next university semester starts at September, but I'll try to implement these features in my free time.

But anyway feel free to ask me about my work or write me about bugs in IRC igevorse or via email: igevorse /at/ gmail.com

Regards,

igevorse

Overview of work this week

In short:

• Implemented improved InstrumentChange element.
• Implemented import midi ports/channels from Guitar Pro and Overture files.
• Fixed bugs with assigning midi channels to instruments.
• Fixed other bugs.

This week I finished improving InstrumentChange element. If you remember, the goal was to show only one item in mixer for the several same InstrumentChange elements. Now it's implemented completely. You can see an example score on the screenshot: we have several InstrumentChanges for Flute, but only one item in mixer. InstrumentChanges are synced, so if you change volume for "Flute" it would affect all Flute InstrumentChanges within the staff (within the Part, if we talk about code).

Also I was working on assigning midi channels to instruments. The first implementation was buggy, so I had to fix more than 10 quite serious bugs: each of them could break the feature. It works now, but solution is complex and affects a lot of processes (loading/saving file, adding/removing new elements, working with sequencer, etc.), so I am afraid I could broke something. There is only one way to be sure: test it hard.

Users was waiting for this feature for years, so if you're reading this post and you can help with testing - you're welcome! My pull request is here. Feel free to clone and test it!

As I said, current implementation is complex: partially because I added an ability to "fill the holes" in midi mapping. Suppose you have several instruments with midi channels 1, 3, 4, 5, 13 and the ports equal to 1. Now if you add a new instrument, it's channel would be mapped to midi channel 2. In previous implementation it would be mapped to channel 14.

Some information for the developers:

I mentioned in previous post that instruments could have the same midi port and channel, but could not have same indexes in midi mapping array. Now they could. It is the simplest approach to "join" all InstrumentChange elements to one item in mixer. All InstrumentChanges with the same midi program just mapped to one channel. Unfortunately, this solution has it's own drawbacks. So, a few InstrumentChanges with different instruments could be showed as one instrument in mixer. If they have the same midi programs, of course. For example, "Flute", "Soprano flute" and other related to flute instruments have the same midi program. This is probably a limitation in a GM soundfont standart. Or I just need to use not only midi program, but instrument->trackName() too for identifying an instrument. I am sure there's a user that needs to make an InstrumentChange from Flute to Soprano flute, so sooner or later I'll have to deal with this. If you have any suggestions - please contact me at any time.

Since now we support assigning midi ports and channels, we can extend our possibilities in import. I implemented import ports/channels from Guitar Pro 3, 4, 5, 6 (*.gtp*) and import channels from Overture format (*.ove). The last one does not support assigning midi ports to staves, as I understand, but supports assigning midi channels. Also, I have no information about *.mgu and *.sgu formats - there is no trial version of Band-in-the-Box application for the research. If I am wrong, feel free to write me.

Also this week I fixed two bugs: issues #29776 and # 29841.

Get ready for the final report!

Key tasks that stalled

It's ok.

Upcoming tasks this week

GSoC is almost over, but I promised to implement MIDI Actions, so I'll find the time for implementing. However, it may take a long time because of beginning of the study in university.

You can find me on IRC #musescore as igevorse or write a comment under the post.

Overview of work this week

In short:

• Fixed bugs with assigning and syncing midi channels

My mentor found a few bugs in my implementation of midi channels, I was fixing them this week.

The first "bug" is actually an unimplemented feature: instruments are still visible in mixer after deleting. I didn't tested it and forgot about implementation. Actually this bug is more serious and leads to another bugs.

Here's some info for developers:

Every instrument has a pointer to the instance of class Channel. We have an integer there that shows our channel number. So, instr->channel->channel may have a value 0, 1, 2, etc. But it is not a midi channel (remember, we have to keep midi port too). We have a midi mapping (Score::_midiMapping[]) to save midi ports and channels. Our instr->channel->channel is an index in this array.

The main function here is Score::rebuildMidiMapping(). This function clears midi mapping and fills it with new values for each instrument: [port 0, channel 0], [port 0, channel 1], etc.

In my implementation I can't just clear it and assign channels because user can change midi channels. When user changes midi port or channel, we change the port and channel directly in _midiMapping. But when user creates or deletes an instrument we should add or remove a midi mapping. It's not easy to find all places where I should change midi mapping directly. Also it might be too difficult to a new developers. So, I avoided direct changing of _midiMapping. Also, since we don't clear our midi mappings, the order of items in mixer wouldn't be changed if we change it in the Add->Instrument window. I fixed it too. The new implementation of rebuildMidiMapping() works like this:

1. We pass through the _midiMapping array and search for the mapping to instrument that does not exists, then delete it.

2. We pass through the Instruments and search for the instrument that does no have a midi mapping (then it's a new instrument) and create a midi mapping for it.

3. Reorder mappings to the order in Add->Instruments.

Now it works pretty well.

The second bug was related to syncing channels in mixer. Since now we can have 2 or more instruments mapped to one midi port/channel, these instruments can't have different program, volume, pan, etc. When you change the volume of one of these instruments, volume of another instrument with the same channel would be changed too. There were some bugs but now they're fixed.

Also I accidentally fixed a few bugs with mixer and midi export.

Key tasks that stalled

Fixing bugs slows the development process :(.

Upcoming tasks this week

Again:

Check JACK implementation for possible bugs.

Finish improving Instrument Change element.

Implement import ports and channels from gtp*, mgu and ove formats (not sure last two support it).

As usual, you can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features that you need and want.

Overview of work this week

In short:

• Implemented automatic control over ALSA ports number.
• Implemented import/export of musicXML files.
• Started working on MIDI Actions and improving Instrument Change element behavior.
• Bugs fixed.

I wanted to become working on JACK MIDI In this week, but was surprised: it was already working!

I finished implementing import and export port/channel information to musicXML format. Since MuseScore does not fully support this file format, my implementation is not full too. But never fear: it works well. As my mentor said, musicXML is a large standard and there is no full implementation of it in any score writer. Also I've done some research and realized that bww, md and cap file formats do not allow saving ports and channels (write me if I am wrong).

Even if we don't have ALSA MIDI Out working, we should keep in mind it. That's why I changed part of code that refers to registering ports and added a support of automatic port creation if MuseScore need it (I made a similar work for JACK ports last week).

Thanks to pedroseq for his comments, he gave me ideas about implementing new features. In first, there is an idea about improving Instrument Change Element. Now when we add this element to staff it creates a new instrument and adds an item to mixer. If we have several instrument changes from Flute to Piano, we'll get a lot of different items in mixer for the same instruments (Flute, Piano, Flute, Piano ...). The idea was to combine same instruments to have only two items in the mixer: Flute and Piano. Described behavior (not combine) maybe considered as a feature: you can set volume, pan, chorus and reverb separately for each instrument. But we decided that new behavior might be better: Staff-text and System-text elements already combine channels, let's do the same with Instrument Change. My implementation is almost done: channels combine successfully, but I have to solve some side problems: for example, "mute" and "solo" options do not work properly now.

Another idea is adding MIDI Actions to all instruments (now we can send MIDI Actions only for Aeolus). MIDI Actions would give us an ability to send MIDI Actions to internal and external synthesizer at some point of time. It is not about music notating, but it affects the sound of score: you can add a portamento, then remove after 5 measures, you can change pan/chorus/reverb, change release time or modulation settings. Since internal synthesizer does not support all midi messages, it's better to use an external one. MIDI Actions have a great potential and implementing it can lead to a big changes in MuseScore. Maybe it will ever have an automation tracks for the midi parameters: volume, pan, chorus...

Key tasks that stalled

All is well.

Upcoming tasks this week

Check JACK implementation for possible bugs.

Finish implementation of MIDI Actions (although I'm not sure I'll finish it in one week).

Finish improving Instrument Change element.

Implement import ports and channels from gtp*, mgu and ove formats (not sure last two support it).

As usual, you can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features that you need and want.

Overview of work this week

In short:

• Implementing automatic control over JACK ports number.
• Implemented import and export of ports/channels in midi and mscx/z files.
• Fixed bugs with selecting audio system and sending "program change" midi message.

This week I was implementing automatic control of JACK MIDI Out port number. Before we had a spin box in Preferences->I/O that helps to specify number of ports, but we didn't have an ability to select ports for each instruments. All instruments were mapped to port 1. Now we can assign channels and ports to instruments and now we do not need a special controls for specifying port number - MuseScore already knows it! If you assigned 4 ports for your instruments, you'll immediately get 4 JACK MIDI Out ports.

Assigning channels is good, but saving them is better. You can save channels in MuseScore native formats (mscx, mscz) and MIDI format (mid, midi). Next week I would make import/export of ports/channels for other supported formats.

There is one unimplemented, but very important feature in JACK MIDI Out: it doesn't send "program change" MIDI message and if you play via external synthesizer, all your staves would sound as grand piano. It is fixed now: changing "sound" in your mixer changes program/patch in the external synthesizer. Of course, if you have the same soundfonts.

Also I've fixed the bug with selecting default sound system on linux. If you run "mscore -F" without pulseaudio installed, no audio system would be checked by default and you'll get a crash in some cases. Now it is fixed.

Key tasks that stalled

It's ok.

Upcoming tasks this week

Finish implementing import/export port/channel information to MusicXML, gtp*, bww, ove and other supported file types.

Begin work on JACK MIDI In.

As usual, you can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features that you need and want.

Overview of work this week

In short:

• I began implementing assigning channels to instruments.
• Found bugs related to changing instruments.
• Fixed bugs with JACK Transport.

I decided not to implement "assigning channels for JACK MIDI Out", but began implementing more complex "assigning channels to instruments" feature. Users have been waiting for this, and now I can "kill 2 birds with one stone" - implementing this feature gives me proper midi channels for JACK MIDI Out too.

So, I continued researching of code related to MIDI and begin implementing.

At the beginning I wanted to change a lot of code to make internal midi system more simple. I changed some code and got partially working solution, but stalled with further implementation. After additional research I realized that current implementation of midi is convenient enough and I can implement this feature with minimal changes of code. My second implementation was simplier.

We can't change channels in "Create Instruments" window because there are only Parts and Staves, not Instruments. So, now we can change port/channel directly in Mixer window.

Here you can see the screenshot of new Mixer window:

It is already working solution, not a sketch. I tested it with QSynth (it shows the input channels) - channels really change.

Now I should implement saving channels to score file and restoring it.

While implementing "assigning channels to instruments" I was researching an existing midi-related code and found a few bugs with "Instrument change" and "Staff-text". Some of them can be fixed, but some not. It's more a design problem.

For example, user can create a piano staff, then add "Instrument change" and change instrument to violin from the 2nd measure. Then he can add "Staff-text" to 4th measure to make violin sound like a pizzicato violin. Now, what should we do if he deletes "Instrument change"? Should we get a piano staff with pizzicato violin from 4th measure? Or piano staff only? It is more a design problem.

Also my mentor found a few bugs in my JACK Transport implementation, I've already fixed them.

Key tasks that stalled

It's ok.

Upcoming tasks this week

Continue implementing assigning channels to instruments: save/restore channels to score file.

Check channels in midi export.

As usual, you can find me on IRC #musescore as igevorse.

Feel free to write me about implementing some JACK-related features that you need and want.