Category Archives: MusicXML

Sprint 72 “Bullroarer” finished

The next version of Zong! is online! Sprint 72 features the first prototype of a pure HTML5/JS score renderer, a complete rewrite of the midi-out module and improved layout for cross-staff beams.

2017-03-03 WebApp Screenshot

The above screenshot shows the first prototype of the Zong! WebApp. It is a pure HTML5/JS implementation and should run in every modern browser, including mobile devices. The great thing is that it is actually using the original Java codebase and is then cross-compiled to JS using the fantastic GWT framework. Currently our webapp supports loading and rendering MusicXML files. Later, we will add more features like playback. We will also provide it as a web component that can easily be integrated into other websites and apps written by other developers. If you are interested in using this component in your project, please contact us so we can take the first steps together.

Another feature is the completely rewritten MIDI export module. It now supports all kinds of repetitions, voltas and jumps (like da capo, dal segno or coda), even in complicated scenarios. But there is still much work to do, like better support for dynamics, instruments and articulations.

We also fixed the layout of cross-staff beams. This turned out to be even more complicated than expected, especially if different staff sizes are supported (as we do!). There is also some room for discussion: Should the short beam flags at the 32nd stems always be placed on the chord side, or should all flags be placed on the same side within a beam? Other than Sibelius and MuseScore we decided to use the second solution because of better readability. Compare the two possibilities below and have a look at the last note. What do you think?

Cross-staff beams in MuseScore:

2017-03-03 Cross-staff beams MuseScore

Cross-staff beams in Zong!:

2017-03-03 Cross-staff beams Zong

 

Sprint 71 “Lur” finished

After nearly two years, which should have been only four weeks according to the original plan, we finally released Sprint 71 today. The last two years were full of work, including the construction of my new home (see my blog, in German), so I had nearly no time left for Zong!. Fortunately, the last weeks I found time again to work on it, and I (again…) intend to continue with it during the coming year.

The goal of Spring 71 was to improve the stability of the MusicXML import and of the layout engine. Indeed, we managed to collect lots of MusicXML files from all over the web (about 12.000 pieces), some with great quality, some with little errors and poor quality, and now we are able to load and layout them all. Of course, the layout quality is still not good enough to publish a version of Zong! for real end users, but at least we can now focus on specific problems, one after the other. We can not publish the test files because of copyright issues, but we run the tests internally.

Another good – and public – overview of the current MusicXML import and layout progress is provided by our implementation of the Unofficial MusicXML Test Suite. There is a status report and a visual report, which brings our layout results face to face with the Lilypond renderings.

2016-12-31 Test Suite

For the next sprint, we are planning to improve the stability of midi-out and the rendering on Android devices and with HTML/JS. Happy new year! 🙂

Demo apps available

Today we pushed Sprint 70 “Bow” to our server. As more and more developers get interested in the Zong! project, we started to write little demo apps which show how Zong! components can be used within other software projects:

  • The Minimal demo simply converts a MusicXML file to a PDF file
  • The little more advanced Simple GUI demo includes a score viewer with a moving cursor and MIDI playback

In this sprint, we created the JavaFX based renderer. We refactorized the musicxml and musicxml-in projects as well as the renderer project, which is now a universal base for all platform-specific renderers (JavaFX, AWT/Java2D, GWT and Android is on the way). We will continue by improving the layout project, including tests based on the Inofficial MusicXML Test Suite.

Sprint 69 “Horn” finished

Yesterday, we pushed Sprint 69 “Horn” to our server. Beside the integration of JavaFX, which is already completed for the Zong! Player, the main focus of this sprint was to extend our automated tests by the Unofficial MusicXML test suite, which was originally created by Reinhold Kainhofer and is now maintained by the Lilypond developers. We started by testing the loading of MusicXML files into our internal core data structures and will continue the tests for layouting and MIDI conversion. The current implementation status is continuously updated by our build server.

Zong! Player ready for Java Web Start

The Zong! Player is an open source audio player for MusicXML scores. It is also possible to convert MusicXML files to other audio formats like MIDI, OGG, WAV and MP3 (if LAME is installed). The program is now based on JavaFX 8 and can be started by clicking on the following button:

http://java.com/js/webstart.png

Oracle has spent some effort to increase the security of Java applets and applications. Therefor, Java Web Start applications have now to be signed using a trusted certificate. Being an open source project, Zong! got a free certificate from Certum. Thank you very much for your support!

Why I don’t like online music notation apps

As I could see at Musikmesse 2013, the trend in music notation programs goes to online services like Noteflight and mobile apps like Scorio. From a developer’s point of view, especially Noteflight is an fascinating piece of software – a whole notation program written in pure HTML5 and JavaScript. However, as a user, I am not convinced of the idea behind online music notation. Here are my reasons:

  1. I have a fixed work area when writing music. This is not only because I need a large screen, a hardware keyboard, a mouse, a MIDI keyboard and a printer, but also because I need to have my peace at my own desktop. In 99% of the time, I write music on the same computer. Online notation programs allow to write music “everywhere”. I just don’t need that. I find it horrible to write music on a tablet PC or even a smartphone.
  2. I prefer printed sheet music. Online programs can also print your music, but their focus is much more on screen display and the viewer’s perspective. Maybe the musicians I know (including myself) are old-fashioned, but we like to play music from printed paper. We take notes with a pencil (without limitations which notes are possibe), and we need no internet connection (we have none in our rehearsal room) and no electric power. I like the idea of sharing files with others over the internet, but this is also possible with e-mail, dropbox and other services, and for sure also within desktop notation programs in the future. I need no web browser for that.
  3. Pay for the time. The price of the programs is currently at about 80$ per year. Suitable desktop notation programs cost about two or three times as much, but only once (bigger updates not included). Since I am happy with my desktop application, the subscription of the online program would be more expensive already in the third year.
  4. Dependency on the vendor. When the vendor closes its service, I can rescue the files by exporting to MusicXML, but I can not use the same notation program any more. This is different with offline desktop applications: When the vendor stops development, I can still install and use the software on my computer as long as I like it.
  5. A technical reason: Web technologies are limited. Although new standards like the Web MIDI API will follow, I think the web is not suitable for high-end multimedia applications. When running in the web browser, you always have an additional layer (the browser) between your application and the operating system, which makes everything slower, more limited and reduced to a compromise that works for all kinds of devices. When you want to fully exploit the power of your computer, there is no better option than running as low-level as possible (already choosing Java for Zong! was a hard decision).

Conducting a virtual symphony orchestra using Zong!

This blog has been quiet for the last four months. Not because the project is dead or frozen, but because I had to concentrate on my master thesis. Luckily I managed to find a topic that is related to music notation, and so I was also able to integrate Zong! into the project and bring it a little bit forward.

The project is called Pinocchio. It is a serious game that should allow young children to become acquainted with classical music by conducting a virtual symphony orchestra. The videos on the website (very outdated) give a good idea about how it works. However, as you can see, conducting was not really realistic yet and the interpretation of the gestures seemed a little bit randomly. So my task during the thesis was to extend the repertoire of conducting gestures, and introduce the ability to load and understand any piece of digital sheet music. This allows a better interpretation of the gestures, since now the context (the score) is known to the system. For displaying the score and rendering it into audio, Zong! is used in the background. It allows to open all MusicXML files, then it computes the needed information and provides it to Pinocchio.

Unfortunately, the project is not open source, and it is not finished yet. So there is no demo I can provide here, but maybe there will be some videos in the future.

Since this was my master thesis, and I needed a lot of time to do it, I had nearly no additional resources left for Zong!. This will change dramatically now 🙂 As the available prototypes show, the technology works and is still easy to extend, so now it is time to move forward to a really useable product, and of course, begin with the editor component. We will post a plan for the upcoming release here within the next days, so stay tuned!

Iteration 51 is out

After many weeks of work, Zong! p0.4.51 is finally out. Although there are no new features which are interesting from a user’s perspective, there are two important changes which are essential for the future development of the project:

  • The core has been completely replaced. While it was based on mutable Java classes and operations using many side effects before, the core is now completely functional. It is now much easier to test and maintain, and undo/redo is now a trivial task. The new core wouldn’t be possible without the excellent work of the pcollections project, which I can really recommend for Java projects of any kind.
  • The musicxml project replaces proxymusic. While this is also a great library which I can recommend to all Java+MusicXML projects, we had problems with the Reflection techniques it is using (applets must be signed then), JAXB’s not-so-optimal XML-to-Java conversion and its speed (on my machine proxymusic needs about 2 minutes to load all official MusicXML 1.1 and MusicXML 2.0 samples, while our new musicxml library needs about 5 seconds). The two projects do basically the same, but proxymusic is automatically generated from the MusicXML schema, while our library is written by hand, which is really a very boring task, but finally it was worthwhile.

The goal for the next iterations is to rewrite the layout engine so that it fits to the functional core. Then, we can continue to improve the layout engine and support more music notation features. We also plan to offer a web service that converts MusicXML to PDF (and possibly other formats).

Zong! Player is finished

Today I finished the Zong! Player, which is the successor of the Xenoage Player, which is not maintained any more. It is able to open MusicXML files and to play and save them as MIDI files. It can also convert whole directories of MusicXML files into MIDI files in a single step.

Compared to the old Xenoage Player, there are some new features available. First of all, it is now based on the Zong! modules (core, musicxml-in and midi-out), which means, that many new features written for the Zong! Viewer and Zong! Editor are automatically integrated into the player and there is a much more stable codebase. Worth mentioning is also the support of soundbanks (like *.sf2 soundfonts) through the new Java Sound engine Gervill. And finally, we have added support for both compressed MusicXML files (*.mxl) and MusicXML opus files (nested in any depth). Of course, there is again an applet version of the player.

We will release it for public beta testing together with the viewer in a few weeks (hopefully before christmas).