lkubuntu

A listing of random software, tips, tweaks, hacks, and tutorials I made for Ubuntu

Category Archives: ubuntu

Why Openlux instead of Redshift?

First, I want to clarify that this is not a post trying to show that one is better than the other unequivocally. This is, instead, a post trying to show my reasons for writing openlux, and the differences between both softwares. I’m sure that many people will prefer the way that redshift works, over the way that openlux works, and that’s awesome!! The purpose of this post is, mainly, to show the differences, and hopefully help you decide which is better for your circumstance :)

My initial reason for writing openlux was because f.lux didn’t work for me, for various reasons (as I outlined in the first post about it) … I was actually unaware of redshift. There were a few people who linked me to it, and I immediately felt slightly disappointed that I hadn’t done my research before (would have saved me quite a bit of work!). Looking into it though, it’s not what I was looking for, and it has some of the issues that made me switch away from f.lux.

Redshift’s mode of operation is different than openlux’s. It primarily functions as a daemon, changing the color temperature automagically, depending on your timezone. This is a really handy feature, however, you don’t have much ability to configure the times. If you don’t have insomnia, and have a regular sleeping schedule, this is probably perfect. You tell it where you live, and it will change the screen color temperature throughout the day, in order to match the light you would receive if you were outside at that time (except at night, of course =P). But in my case, I can stay up until 4-5am, unable to sleep at all. Having the screen automatically change to a higher color temperature when I’m trying to go to sleep is most definitely not what I need. Now I could change the timezone every so often, but I’d rather have something in which I control when the screen color changes, instead of having to work against the program. I am aware that redshift has an option for manually changing the color temperature, but you don’t have much control over other options (such as animating to it, or individual control over RGB channels).

Redshift also uses color tables in order to compute the RGB values from kelvin temperatures. This allows for maximum accuracy within the range it provides (1000-25100K), however, it doesn’t allow anything outside of the range. On the other hand, openlux, works using Tanner Helland‘s algorithm, which allows for a theoretically infinite (practically 0-232, because it’s stored in a 32-bit integer), but less accurate result. Personally, I prefer using an algorithm, but there are definitely things to say about using a color table instead. The algorithm is pretty accurate (I think it’s a maximum of ~3-5% off of the original value), but if you’re within the range that redshift provides, it’s always nice to have 100% accuracy!

The main philosophical difference (that influences how the programs evolve) between redshift and openlux is the goal: redshift is more oriented towards being a standalone, fully-featured program, while openlux is oriented towards being a program that only does one task (change the screen color temperature), and focuses on that one task. It leaves tasks such as changing the color temperature in accordance with the timezone to other programs specialized for this (such as cron), or manually. Redshift tends to go more on the side of “run it, and forget about it”, while openlux leans more on giving the user maximum control and flexibility.

There’s definitely something to be said about both philosophies, and different users will appreciate different philosophies. I personally prefer the one of having full control at all times, but there are many users who would prefer to just have the program manage it for them automagically.

If you’re not sure which to use, try both! See which one works best for you. After all, GNU/Linux is all about choice :)

If I’ve made any mistake in this article, please let me know. This post is most definitely not about saying that one software is better than the other. While I, of course, prefer openlux, I want this to be a fair comparison of both softwares, so that users can better decide which software they want to use for themselves.

Openlux 0.2 beta – Animations, iOS port

I wrote openlux around 2 and a half weeks ago, as a simple, libre alternative to f.lux that addresses a few issues I’ve encountered with it. I’ve since used it everyday, and I’ve actually noticed an improvement in my sleep!

However, my iPad still uses f.lux (or, until today, at least). No, in this case, I’m not worried about the fact that f.lux is proprietary (it’s an iPad), but earlier, when my sleep was really messed up (and by messed up, I mean, I was going to sleep at 7-8am), f.lux would automatically switch to 3400K (instead of 2300K), which definitely didn’t have a positive impact on my sleep. Also, it only goes down to 2300K, doesn’t allow much customizability, and doesn’t always work how I want it to work, etc.

So after spending quite a long time (basically ever since I released the first version of openlux) working on the port, it finally works!!! It doesn’t work as well as I wanted it to (multiple colors output the same value, compressing the color range … I tried lerping values, but it ended up giving garbage), but at least it works!

Animations literally took about the last hour of developing this version (in other words, barely any time at all, compared to the time needed to develop the iOS port), since, luckily, I only encountered one bug while making it. The point of animations is not for visual bling, but rather to make it easier on the eyes if it’s run automatically (e.g. via cron).

Other than those, there are a few minor features, such as optional relative adjustment of colors (“-b 10” will set the blue channel to 10, “-b +10” will add 10 to the blue channel, and “-b -10” will remove 10), and saving/resetting gamma values (mainly just a by-product of working on the iOS port).

If anyone would be interested in testing this on their iDevices, I would really appreciate it ^^ Though it works fine on my 1st generation iPad, I don’t know if it will work on other devices too. I wrote instructions on how to compile and run it here: https://github.com/AnonymousMeerkat/openlux/wiki/Compiling-for-iOS :) I’m not aware of this being able to cause any permanent damage to your device (my device works fine now, even after the display being severely messed up multiple times), but if you’re scared, stick with f.lux for now. Quick note: it doesn’t work on iOS <4, since it needs to retrieve the gamma table (which iOS versions <4 don’t support).

To wrap up, here’s a few examples of the new features that come with openlux 0.2:

openlux -k 1000 -a 10000         # Animates to 1000K in 10 seconds (10000 milliseconds)
openlux -k 1000 -a 100000 -d 100 # Animates to 1000K in 100 seconds, with a delay of 100 milliseconds per "frame" (less CPU usage)
openlux -k 1000 -g +10           # Sets the color temperature to 1000K, but adds 10 to the green channel
openlux -R                       # Resets to the last saved gamma table (openlux automatically saves the gamma table the first time it's run per boot)
openlux -s                       # Saves the gamma table

How to set up WineASIO

Step 1: Install WineASIO

If you use ubuntu, run this in a terminal:

sudo apt-get install software-properties-common wget
sudo add-apt-repository ppa:kxstudio-debian/kxstudio
sudo apt-get update
sudo apt-get install kxstudio-repos
sudo apt-get update
sudo apt-get install wineasio

If you use Arch Linux:

Add the Arch Audio repository, then run in a terminal:

sudo pacman -Sy wineasio

Step 2: Register WineASIO

If you have a 32-bit WINE prefix, or you have a 64-bit one, and you want to run a 32-bit ASIO application (e.g. a DAW), run this:

regsvr32 wineasio

If you have a 64-bit WINE prefix, and you want to run a 64-bit ASIO application:

wine64 regsvr32 wineasio

If everything went smoothly, you should see a message similar to:

Successfully registered DLL wineasio.dll

However, you may receive:

Failed to load DLL wineasio.dll

In my case, the reason why this message occurred, is that wineasio.dll was installed to the wrong location. I had 2 problems, actually. It was first installed to /usr/lib/wine, not /usr/local/lib/wine (I have a custom-built version of WINE), and second, even if it had been installed to /usr/local/lib/wine, it wouldn’t have worked, because, in my case, WINE loaded 64-bit libraries only from /usr/local/lib64/wine, and 32-bit libraries only from /usr/local/lib/wine. The package had installed the 32-bit version of wineasio to /usr/lib32/wine, and the 64-bit version to /usr/lib/wine.

Try moving the wineasio .so’s to these places:

  • 64-bit wineasio .so: /usr/lib64/wine
  • 32-bit wineasio .so: /usr/lib/wine

Then try again. If you still have problems, leave a comment below, and I’ll try my best to help =)

Step 3: Setup JACK

WineASIO uses JACK as the backend for the audio, so, not surprisingly, JACK has to be setup correctly for WineASIO to function correctly. I wrote an article a while back about how to do this.

Step 4: Profit!

It’s that simple! Now all you have to do is to load up the application you want, and set the ASIO driver to WineASIO =)

Creating an Orchestral track under Ubuntu REDUX – Part 1: Choosing a DAW

So, I originally thought this series was useless, and, well, since I didn’t cover some of the more important sections, it pretty much was =P

But one person asked me to finish it, which was the first time I saw that it was useful, to at least someone, so I decided maybe it’d be a better idea if I make a redux of it, because the first one had many issues (and I’ve learned a lot since then).

One of the issues was that it took LMMS as the base DAW (Digital Audio Workstation), which, as I have learned since, is definitely not the best DAW for orchestral music production (IMHO). Since I have tried a couple of DAWs, I’ll share my thoughts on each one =) Next part will focus on setting them up.

  • LMMS:
    • Pros:
      • It’s somewhat easy to install (you might need to compile it though)
      • Linux-native
      • Very intuitive at first, and good for beginners
    • Cons:
      • Very buggy (minor bugs, but still annoying)
      • I personally hate the automation
      • Multiple MIDI inputs for a VSTi is very hard (I haven’t managed to ever make it work)
      • VSTi’s take a loooong time to load (though this is most likely an issue with having a linux-native DAW using windows VSTi’s)… especially Kontakt, which is probably the most important VSTi you’ll need for orchestral music production
    • Conclusion: Good for beginners, not good for orchestral music production
  • QTractor:
    • Pros:
      • Simple
      • Minimalistic
      • Logical
      • Intuitive
      • Consistent
      • Fast (the program is fast)
    • Cons:
      • More work to install and setup than LMMS (especially with setting up windows VST support)
      • Buggy
      • Crashes a lot
      • Piano Roll is pretty bad (IMO)
      • Not as pretty as most others (though, tbh, that isn’t too important XD)
      • Though the workflow is very consistent and intuitive, the word “fast” would definitely not be the best to describe it
      • I have never been able to successfully load a windows VST on it yet (when I was actually able to _find_ the VST, it crashed while loading it)
    • Conclusion: I like this one a lot, but its cons make it only really useful at a conceptual stage (IMHO, at least)
  • I will skip a lot of other Linux-native DAWs, because I haven’t had enough time with them to give a somewhat decent Pro/Con list to. However, I find that OpenOctaveMidi – though it never worked for me – seems to be (from the features list) the most promising linux DAW so far (sadly, it hasn’t been updated in 2 years).
  • REAPER:
    • Pros:
      • Free (kinda … the trial never really ends)
      • Well maintained (updates pretty much every week or 2)
      • Works almost flawlessly under linux
      • Very customizable
      • Piano roll has a _really_ useful time-stretching feature (when multiple notes are selected, CTRL+Drag on the edge of any of the selected notes, and it will time stretch it)…. something I really miss with other DAWs
    • Cons:
      • It isn’t actually free… but you can keep on using it as long as you like for free (the trial isn’t enforced)
      • (I’ll have to update this later… I know I’m missing a few, but I haven’t used it for so long that I forget >.<)
      • It might have frozen a lot, that may be why I don’t use it anymore (as I said, I forget)
    • Conclusion: It’s great, but I forget what I didn’t like about it…  TODO: FIX THIS!!
  • Ableton Live:
    • Pros:
      • As its name suggests (“Live”, not “Ableton” =P), it’s great for live performances, due to its really neat session view (basically, you can put a lot of 1 bar patterns in it, then play them at different times)
      • Its macro feature is _really_ useful, as it basically (AFAICS, I’ve never used it, but I’ve seen people use it) an automation that automates multiple other automations. Though its use in orchestral music is not that prominent, it’s very useful in electronic music (and since my style usually has a mix of both electronic and orchestral, I would use this a lot, if I still used Live).
      • Automations are really well made
      • CTRL+Drag. Seriously, it’s probably one of my favourite features from it… so simple, but so powerful (while dragging moves a clip or note, CTRL+Drag will duplicate it and move the duplicate… very useful!!)
      • Close integration with Max, a tool that kind of lets you create your own synths or effects
    • Cons:
      • Midi CC automations are terrible, and sometimes don’t even work! This is the main reason why I don’t use it, as in orchestral music, Midi CC automations are pretty much one of the most important things you’ll use.
      • The display is very buggy under linux
      • The Midi editor needs work (it’s workflow is rather slow)
      • It doesn’t bridge VSTs. So if you’re using the 64-bit version, you can’t use 32-bit VSTs.
      • It crashes a lot
    • Conclusion: Though it’s really great for electronic music, it’s not so great for orchestral music
  • Studio One:
    • Pros:
      • Best DAW for Midi CC automation that I’ve used so far (it works both on clips, and on the timeline!)
      • Automation is pretty good (you can create square, triangle, and sine waves really easy on it)
      • Very intuitive (I picked it up really quickly, compared to nearly all other DAWs I’ve used so far)
      • Its plugin browser is also really neat (you can organize it by vendor, category, folder, or just flat)… best one I’ve seen so far
      • Close integration with Melodyne, an apparently really cool audio editor (I still haven’t figured it out though XD)
    • Cons:
      • The display is very buggy under linux (sometimes the timeline time vertical bar indicator [for lack of a better word] doesn’t even show! Also, the rectangle selection doesn’t show either)
      • It’s buggy all-around (I don’t think this is linux-related)
    • Conclusion: Best DAW I’ve used so far for orchestral music production, but it’s very buggy!

I would have included the setup part in this one, but I realized that it would have probably taken 2 more articles (plus this one), so I decided to just give a quicker article at first, to kick off the new tutorial “series” =)

Oh, and, if I may add… I’m working on my own DAW right now, which is fully modular, so if there is something that isn’t quite right, then it’s easy to change it =) It’s kind of a precursor to SythOS (same concept…. 3D virtual environment, network-enabled, fully modular, timelines, timeline branches, etc…), but it’s much simpler (since it’s only an audio workstation). I’m planning on releasing it sometime by the end of this year =)

Some updates

I thought it might be fun/interesting/possibly useful/useless/whatever to create a post with updates on different projects I’m working on that are related to (or have been posted on) this blog.

Orchestral Tutorial Series

I haven’t posted anything in this tutorial for a really long time. Why? A couple of reasons. First, I needed a break, second, JACK stopped working (once I fix it, I’ll update the first part =P ), and third (also the main reason), is that there didn’t seem to be a great interest in the tutorial series (very few hits per day, if any). Which makes total sense (I’m definitely NOT the best person in this field at all).

So does anyone want me to finish it (the next part is going to be about how to, well, create a track using LMMS… like LMMS basics, that kind of stuff)? If anyone does, I’d be happy to do so. But if there isn’t really any interest (which I would totally understand XD), I probably won’t finish it.

Relinux

Relinux 0.4 was a disaster. I think that nearly everyone who used it can agree with that. So, instead of trying to fix all of the issues, and constantly fix the architecture, etc… , I’ll rewrite it! Again! This will be the 7th time I’m rewriting it (yes, I kept count =P)! I’m not kidding.

I’m kind of designing it off-and-on (my main priority is SythOS), but it’s definitely going to be better than 0.4!

Some quick notes: I’m debating on whether it’d be a good idea to call it something else, since I’m not really sure that any product is still to be considered the same product after its 7th rewrite… and because I’m not sure I’ll just want to support linux (I really want to make it work on BSD-based distros!).

I’m also not sure if I’m going to be using C, C++, or SyC (see the SythOS section). If I complete SyC before I start working on relinux, it’ll definitely use SyC, however, I’m not sure if I’m going to wait for that long. I know that if it uses C++, it’ll most probably use Qt.

SythOS

Since I wrote that post on SythOS, I’ve been constantly improving the concept. I’m not going to reveal too much (I’ve had enough of people stealing my ideas… and code), but it’s basically now a fully 3D environment, and everything is editable (without a separate “mode”… if you edit an object, you’ll edit it in real-time). I’ve already figured out how exactly one could create an audio track inside it, same for video, image editing, texturing, gaming (duh), and also, how using SythOS could be much more efficient than using, erm, “normal” solutions. I’ve also figured out most of the “how” of SythOS (i.e. how it’s going to be built, how everything is going to work, etc…).

SythOS is actually going to use a custom programming language, not because it’s impossible to create it using already existing languages (I was almost going to use C++ for it), but because it’d be much faster and easier to use a different language (that I’m designing right now).

The language (named SyC … SythOS C … okay, it’s not a brilliant name … neither is SythOS, for that matter XD) is, well, based on C, but is designed to be more consistent (I got slightly annoyed by the minor inconsistencies with C =P), and, if used correctly, faster. What? Faster? How? Well, it has an extremely powerful pre-processor… which is literally the language itself! Okay, let me rephrase: Preprocessor instructions are normal code. So it’s theoretically possible to run an entire software inside the preprocessor (why? good question!). But yeah, it’s extremely useful for optimizing code that could be run at compile-time. Also, because of this, it’s theoretically possible to extend the language itself (or even, write code in a separate language, which will compile to SyC) using the pre-processor!

Since it’s very possible that I might have confused you (I’m terrible at explaining things, if you haven’t already noticed =P), I’ll give a code example of what I mean (I haven’t finished designing SyC, so the syntax you see here may very well be changed once SyC is done):

@int foo = (@int var) { // Built-ins are namespaced using "@"
    @return = var + 10; // Return is no longer a keyword, it's a variable!
};

// If you use # in a variable name, it's now _forced_ to be used as a pre-processor instruction
@CODE #loop = (@int times, @CODE code) {
    @return = "";
    for (int i = 0; i < times; i++) {
        @return += code + ";"; // NOTE: The "+=" and "+" will probably NOT be used in SyC!
                           // This is just an example for the pre-processor, so please ignore that
    }
}

@char * #error = "ERROR"; // Think of it kind of like:
                          // #define error "ERROR"
                          // If you wanted #define error ERROR , you'd change @char* to be @CODE

@int main = () {
    @return = 0;
    @int var = 10; // NOTE: This'll probably have to be constant... SyC's design is not complete yet!
    @int var2 = foo(var); // This will compile normally... it'll do a function call
    @int var3 = #foo(var); // This will compile as: @int var3 = 20;
    loop(20, // Notice that it is not invoked as #loop ... this is because loop is already marked as a pre-processor instruction!
        var3++;
        var2 += var3;
    ); // This will compile as:
       // var3++;var2 += var3; var3++;var2 += var3; var3++;var2 += var3; etc...

    if (var3 > var2) { // Let's just say this is an error
        @return = 2;
    }
}

So, back to SythOS (instead of talking about SyC), I am not going to ask for people to help on this project (in contrast to what I did with CosmOS). Reason why, is that the last couple of times I did that, it turned out to be a complete disaster. So I won’t do that again! However, I’m definitely not closed to help. It’s just that I won’t be “requesting” help, persay (I would appreciate it though =P).

I haven’t done any code-work on SythOS, as I’m still trying to finalize the design (especially of SyC, as I’ll need to make a compiler for that before I can actually start working on SythOS itself)

This blog

To be honest, I’m not exactly sure what to do about this blog. I’m definitely not going to delete it, but since I’m not using ubuntu anymore, very few things I do on here relate to ubuntu anymore. Sure, I make some tutorials which talk about how to do stuff on linux, but nothing specific to ubuntu.

I’m not sure whether I should continue doing these kinds of posts here (which are not totally related to ubuntu), or not… Though I guess it isn’t too important of an issue, I’m just wondering, would people mind if I kept doing these (since it is promoted on planet ubuntu and other various ubuntu-related websites… and I definitely don’t want to lose them!)?

Creating an orchestral track under Ubuntu – Part 4: Designing the track

Part 5: Upcoming

This is by far the hardest/most time consuming part of creating, well, any kind of track (okay, almost any kind…). So without further ado, let’s dive into it! Oh yeah, quick note, I have next to no knowledge whatsoever in music theory, so if I use the wrong terms and such, please forgive me! The advice I’m giving here is mostly from my own observation of “epic” orchestral/soundtracky tracks I’ve listened to, so, well, don’t expect a perfect guide here :P

The first part you should always start with is to figure out the big picture of the track… or, if you want, the “outline”. The most common outlines (that I observed) would be:

  1. ABA – Two sections, A, and B. You should be able to tell where you run the sections from the name XD . This is the one I used in Muffin Factory (though the last A section was very short).
  2. Theme, slowly “crescendoing” to the climax? – Not sure how to call this, but AFAIK, this technique is probably the most used by Clint Mansell (the musician who made the Requiem for a Dream theme). Or rather, Mansell uses it in nearly all of his soundtracks lol. This technique, as you can probably tell, is very powerful when used well (and when you have the appropriate breaks, because if it simply crecendoes without any kind of break, it becomes extremely boring).
  3. AB – Two sections, A being the intro, and B being the actual track itself. This is probably the most standard one used

Okay, let’s assume we have an outline now. So now we have to get a musical seed/theme (though for some, it may be better to do this before figuring out the outline). Since this tutorial is for creating “epic” orchestral tracks (i.e. more like battle scene-type stuff than emotional or classical stuff), I will only focus on a couple. I know that my suggestions are not too helpful, but this is because seeds are the most subjective parts of creating a track. It’s very hard to create guidelines for seeds.

  1. Battle theme. The musical seed should be short, suspenseful, and should NOT be in major. This will repeat a lot, with variations, so make sure that it’s not ultra complex either (in “epic” orchestral music, simplicity is key). Remember that what makes a battle theme “epic” is almost always the percussion element, so the seed is less important than the percussion itself.
  2. Victory battle theme. This is NOT a victory theme, this is a victory battle theme. The difference, put in movie terms, is that a victory theme is AFTER the battle, and a victory battle theme is IN the battle, but the good guys are obviously going  to win (Listen to “I am the Doctor” to see what I mean). Okay, enough talk. Basically, this is usually in the major key (but can be in the minor key if you know what you’re doing), and short (but it doesn’t have to be as short as a pure battle theme). It doesn’t have to be too suspenseful either (for rather obvious reasons). Also, though percussion is still very important here, it’s much less of a key element than in a battle theme, so do spend more time making sure the theme is good.
  3. Theme song. This is my favourite, as you’re really not limited to anything! This can be almost literally whatever you want (FINE, I take that back, you’re NOT allowed to use a happy hardcore melody … geesh). So no guidelines here, just what you think is best for the theme you’re trying to make (e.g. don’t use a major key on a dark theme XD). Actually, I’ll take that back too… there is still one guideline: Don’t make it complex. Adding complexity to it will really degrade the quality of the theme itself, and will stop you from being able to further develop it throughout the track.

Bingo, we now have our musical seed! Or at least, we should have a seed. Now time to figure out the accompaniment! These are the basically the elements you may want to have for the accompaniment:

  • Driver. No idea what’s the correct term for this, but I like to call it a driver, because it drives the track forwards (and, of course, lets you plug in your graphics card as well!). This is usually done in percussion:But it can also be done harmonically (sorry, the sound isn’t too good on this one):
    When done in either (percussive or melodic), it can’t be too interesting or complex, but at the same time, it can’t be too repetitive or boring. Remember, the point is to drive the track forward, and not to direct attention to it (if it’s too interesting/complex, or repetitive/boring, it’ll drive attention to it, and away from the track itself)
  • Basslines. Seriously, this is not only for rock tracks! Use cellos, violas, and basses for this (octaves are very useful when you need to make it “bigger” too).
  • Counter melody. I haven’t really experimented myself in this section, but from what I noticed, it’s very useful for transitions or fillers. I generally shy away from it, due to it sometimes making the melodic part of the track more complicated than necessary (and trust me, you don’t want that in “epic” tracks, it pretty much removes everything that’s “epic” about the track), but it can be useful when used well.
  • Choir. You won’t always want to have this, but if you use it well, it can add a lot to the track. If you don’t use it well (like I did :( ), it’ll make the track sound cheesy. The creation of the choir part is similar to basslines, except that you specify it in chords, not in octaves or single notes (usually).
  • Percussion. Yes, I did talk about this under “Driver”, and it should usually stay there, but sometimes the need for percussion is elevated (e.g. a battle theme), and then percussion becomes as much (if not more) of a key element than the melodic seed itself. So then, it has to try to attract attention to it (as compared to it being a driver, where it tries to attract attention away).

Great! Now that we have all of that sorted out, it’s time to work on the track itself :D

Notice that I didn’t go into any kind of detailed explanation about how you must develop it. That’s for later, for now we just have to “design” the track, not implement it. Put in programming terms, what we’re doing is this: “I’ll make a calculator written in C++, using Qt, and will use standard menubars, and standard buttons for each of the mathematical operators”, NOT this: “I’ll have a file menu, with Save and Quit, an Edit menu containing Cut, Copy, Paste, and Preferences, (insert more talk about menus here), the buttons will be arranged in a grid layout (more talk about layouts), (etc…)”.

P.S. Sorry for posting this so late, I’ve had personal issues lately that kind of made it harder for me to write this.


Part 5: Upcoming

Creating an orchestral track under Ubuntu – Part 3: Setting up your orchestra


This part isn’t really hard, but it takes a lot of time to find good orchestral samples, so I’ll simply list some that I’ve used, or heard good reviews about (and good music from):

  • 3.5GB collection of orchestral soundfonts: Seriously, this is a must-have, even if you have better alternatives! Though it is only 3.5GB (unpacked), it contains a LOT of soundfonts. And I mean, a LOT. And not only orchestral soundfonts (though it is mostly orchestral), so if you need to integrate other types of instruments, it does have some interesting non-orchestral ones in there.
    • Pros:
      • Free!
      • Some of them are somewhat HQ, or at least sampled (Bellatrix, (S)GM, Gothic harp, Hades strings, to list a few… you can easily find which ones are sampled by looking at the filesize (and dividing it by the number of instruments available) )
      • Easy to setup, all you need is a soundfont player (except for Bellatrix, you’ll need to install an sfark extractor)
      • A LOT of soundfonts
      • It’s non-HQ-ness and lack of a rich sound actually makes it a really handy tool when you really don’t need a rich sound.
    • Cons:
      • Most (if not all) of them aren’t HQ
      • None of them have a very rich sound (seriously, though it may sound okay to you, after you use something that’s actually HQ, you’ll see the difference… big time)
      • A LOT of soundfonts … yeah, I copied that over. That’s because of the problem with having too much choice. That’s why I just check the filesize, and get the one with the biggest, since it’s much more likely to be better quality :P
  • ProjectSAM Orchestral Essentials: I don’t really know what to say… the sound quality is amazing, but it’s seriously overpriced. Look, you can barely customize which instruments you’ll use (they come in bundles, which is seriously annoying when you’re trying to have fine-grained control over your track), the settings/effects are not very powerful, and Kontakt (it’s a VST that is needed so that you can use it) takes hours to load under LMMS, plus, the demo version (of Orchestral Essentials) expires after 15 …. MINUTES. Of course, all you have to do is to reload the library from Kontakt (by removing it, then adding it back, which actually takes about 20-50 seconds), but really… I personally don’t find any appeal at all to this one.
    • Pros:
      • Amazing sound quality (probably the best I’ve ever heard)
    • Cons:
      • Totally overpriced
      • Kontakt takes a long time to load under LMMS
      • Demo only runs for 15 minutes before requiring you to manually reload the library
      • No good effects, and those that are included don’t work too well (from my experience)
      • Instruments are pretty much bundled up, no real way to get individual instruments and build a hand-picked “orchestra”
      • Not too many instruments are available either
  • EWQL Orchestra: Please understand that I have never tried this! This review is only from what I’ve heard, both reviews and, well, music XD The sound quality doesn’t seem to be as good as ProjectSAM’s quality (the richness of the tone seems to have been diminished a bit, though I could be wrong), but (I’m not sure if it’s only because of the artists I listened to though) it seems to be able to have more “emotion” to it. Reason why I say that, is that it seems to be able to have different styles of how the instruments are played… I wasn’t really able to get this from Orchestral Essentials, or, for that matter, anything else that I’ve tried. So it may be some kind of technique that I’m not aware of, but it seems to be good in that section. Also, it’s MUCH more reasonably priced than ProjectSAM (their smallest package costs $145, and is 11GB, compared to ProjectSAM’s Orchestral Essentials which costs ~$360, and is 6GB, AND you can customize each instrument individually).
    • Pros:
      • Great sound quality
      • Reasonable price
      • Possible different styles(?)
    • Cons:
      • Still costs a lot
      • The only way to get really good sound quality is to go for platinum (24-bit depth is actually noticeably better quality than 16-bit), which costs a lot
      • No idea if it works on WINE well or not (not a con exactly, but it could be :P)
  • Miroslav Philharmonik: This is the one I use. Why? The sound quality is perfectly decent (not as good as EWQL or ProjectSAM though), it’s rather small (7GB), it contains a complete orchestra (including coughing & sneezing sounds… I’m not kidding!), a decent choir, the VST takes anywhere from 2-5 seconds to load on LMMS (a HUGE reason to use it for me), and the VST itself is very powerful.
    • Pros:
      • Decent sound quality
      • Reasonable price (the demo’s timeout is not too short either)
      • Complete orchestra
      • Small
      • Decent choir
      • VST is very fast to load (and quite responsive too)
      • VST is very powerful (you can layer 16 different instruments, apply 4 effects per each instrument, and each effect, all 20 of them, work very well)
      • Easy to use
    • Cons:
      • Still costs money
      • The choir sounds like as if they just copied over soundfonts from that 3.5GB orchestral soundfont link I shared above. Seriously, they sound very similar, AND, sometimes, it seems like as if they’re just repeating the same choirs, but under different names (for example, FA and AH sound identical… I don’t hear the F at all)!
      • The sound quality could be improved
      • Some of the “solo” instruments are unavailable as an ensemble (e.g. the tuba… yeah, I know, I’m stupid for wanting a tuba ensemble :P)
      • Rather high CPU usage is constant, even when no sounds are being played

I hope this can help someone! I strongly encourage you to do your own research before buying any of these though.

If you use anything else, or have another pro/con for an existing product, let me know, I’d love to make this list more complete!


Creating an orchestral track under Ubuntu – Part 2: Setting up LMMS


First, to address the question: “Why LMMS?” I’m actually not a huge fan of it, but, IMHO, it’s the best way to start producing music under linux if you’re kind of new to it (music producing under linux).

So… what’s so hard about setting up LMMS? Isn’t it just a matter of going to the Ubuntu Software Center, typing in “LMMS” and installing it? Yes and no. Yes, because that does, in fact, install LMMS. No, because it doesn’t add VST/VSTi support (which you’ll really want later on, trust me), AND, it doesn’t set it up either.

Now for the simple way:

sudo apt-get remove lmms
sudo apt-add-repository ppa:ubuntu-wine/ppa
sudo apt-add-repository ppa:kxstudio-team/ppa
sudo apt-get update
sudo apt-get install wine
sudo apt-get install lmms

That should work just fine (and should have VST support). But what if it doesn’t? This is where it gets a bit harder.

First, we’ll have to download LMMS: https://sourceforge.net/projects/lmms/files/lmms/ . Get the .tar.bz2 archive. The next step is rather obvious: Extract it! Right…… so after you’re done that, in a terminal, cd to where it’s extracted, and run this:

sudo apt-get remove lmms # Make sure that LMMS is not installed
sudo apt-get install libqt4-dev qt4-dev-tools build-essential cmake libsndfile1-dev libasound2-dev libjack-jackd2-dev libsdl-sound1.2-dev libsdl1.2-dev libsdl-mixer1.2-dev libfluidsynth-dev libfftw3-dev libstk0-dev stk wine wine-dev libwine-dev libwine libsamplerate0-dev libvorbis-dev libvorbisfile3 libvorbisenc2 # Install the required libraries to build this
mkdir build
cd build
cmake .. -USE=vst # Make sure we have VST support!!
make # You can add -jN to it, where N is the number of threads running concurrently, if you want to speed it up (assuming you have at least N cores)
sudo make install

There! It should work now!

Now we have to setup LMMS. Simply open up LMMS, and a configuration window should appear if this is the first time you opened it. If it is not, then go to Edit->Settings. Lets go to “Paths” (the folder icon). The defaults should mostly be okay, except for the “VST-Plugin Directory” one. Change that to the directory where your VSTs are (create one if you don’t have one yet. This is important!):

lmms-settings-paths

Then let’s go to “Audio settings” (the speaker icon). Change the audio interface to JACK, and make sure there are 2 channels:

lmms-settings-audio

Once you’re finished with that, let’s test! Click on the top track (it should look kind of like a light blue/cyan clover, without the stem, or like 3 circles) to open up the “Triple Oscillator” settings window, and click on one of the piano keys. If you don’t hear anything, make sure JACK is setup and running, the audio is at 100% and not muted, then restart LMMS.


Creating an orchestral track under Ubuntu – Part 1: Setting up JACK

 

In my previous post, I was talking about (okay, fine, advertising) a track I made under linux, using LMMS, and I said I would write a tutorial on setting up an audio studio, and creating a track with it, so here it is! I’ll dividing this tutorial into multiple parts, so stay tuned (one way to do this is to subscribe … hint, hint ;) )!

This part, as the title says, is to setup JACK. This is probably the most frustrating step in setting up your studio, but it’s very important! Most people will try to make it work with a program named QjackCtl. If that works for you, awesome! But it never worked for me. So instead, I’ll show you how I made it working, well, without it (mostly).

Here is the command I run on my computer to start JACK. It’s probably not optimal, but it works for me:

killall jackd;killall pulseaudio;jackd -R -t 1000 -d alsa -P hw:0,0 -r 48000 -n2 -D

This will probably not work on your computer, but we’ll test it, using alsaplayer (install it if you don’t have it yet, and make sure that the volume levels are at 100%, and nothing is muted):

alsaplayer -o jack PATH/TO/AUDIO/FILE.mp3

And, of course, replace PATH/TO/AUDIO/FILE.mp3 to the path to an audio file (that you know works, and for your convenience, I’ve uploaded a working test audio file here: http://www.uploadmb.com/dw.php?id=1375942423). The test is simple: Click on the play button. Do you hear audio? If yes, then JACK works! If no, then, well, do I need to clarify this? :P

Anyways, if it doesn’t work, what you’ll have to do is to try EVERY. SINGLE. AUDIO DEVICE. (and subdevices). Sounds like a lot of repetitive work, right? It is! So to get the audio device list, open up QjackCtl (I said that we’d get it working mostly without it, not completely!), select “Setup”, and click on the arrow beside “Interfaces”:

qjackctl-interfaces

Now, if you look carefully, you might find a red circle around a certain area. That area contains the hardware ID (for lack of a better term) which we will be giving to JACK. So re-run this command, changing the part in bold with the ID you saw:

killall jackd;killall pulseaudio;jackd -R -t 1000 -d alsa -P hw:0,0 -r 48000 -n2 -D

And then re-test JACK (using the alsaplayer test I mentioned earlier). If it doesn’t work, keep on repeating the JACK step, changing the hardware ID each time, and, of course, test it. Once it works, package it up in a script, like this:

#!/bin/bash
killall jackd;killall pulseaudio;jackd -R -t 1000 -d alsa -P HARDWARE_ID_HERE -r 48000 -n2 -D & # The ampersand at the end is intentional, as it runs it in the background

Save it, and chmod +x it (set it as executable), then run it when you need JACK.


Bonus: Routing Pulseaudio to JACK

Don’t worry, this part is simple :D . Make sure JACK and pulseaudio are running (you can run pulseaudio by running this: pulseaudio &), then run this:

pactl load-module module-jack-sink channels=2; pactl load-module module-jack-source channels=2;pacmd set-default-sink jack_out

You might have to re-run it, and restart applications using pulseaudio.


This is the full script I use to start JACK, and route pulseaudio to it:

#!/bin/bash

killall -KILL jackd
killall -KILL pulseaudio
jackd -R -t 1000 -d alsa -P hw:0,0 -r 48000 -n2 -D & # REMEMBER TO CHANGE hw:0,0
sleep 3
pulseaudio &
sleep 3
pactl load-module module-jack-sink channels=2; pactl load-module module-jack-source channels=2;pacmd set-default-sink jack_out
pactl load-module module-jack-sink channels=2; pactl load-module module-jack-source channels=2;pacmd set-default-sink jack_out

 

My thoughts on Mir

EDIT 27/08/15: I apologize for the harshness of this post. I was quite upset about this move when I wrote this.

If you aren’t aware, Canonical is planning on writing a new display server, competing to both X11 and Wayland, named Mir.

I’ll state my opinion right now: I really do NOT like this move. The rest of the post is the “why” of my opinion. I have not written all of the “why”, because some of the reasons I thought of lacked enough proof to back what I said (such as Canonical becoming another Microsoft or Apple, trying to take over the linux world ;)).

First, the segregation. Let’s assume that Mir is, as was planned “A … that is extremely well-defined, well-tested and portable.” (this is very hard to do, in fact, there are only a very few amount of software and libraries that are this good). Now this would cause a horrible issue of segregation, because now application developers that write applications for Mir will exclude people who do not have Mir (kind of an obvious issue though). Most application developers will use a toolkit, such as Qt or GTK+, which provides an abstraction layer that will allow the applications to run on any display server (though, of course, this requires patching them to support the display servers, but canonical, IIRC, has promised to do this, at least for Qt), so this is less of an issue. The bigger issue would be with the 3rd party graphics drivers. Both major GPU manufacturers (Nvidia and ATI) are already having issues with giving X11 support to their drivers (though Nvidia has considerably less issues than ATI). Now comes along Wayland, an alternative to X11. Back in 2010, Nvidia clearly stated that they do not have any plans to support wayland (they seemed to have changed their mind though, or at least, considered it), and ATI does not plan on supporting wayland anytime soon. This is reasonable for the companies and for linux. As long as X11 will still be supported until both companies officially support wayland, everything should be somewhat okay. But then comes along Mir, a company-lead alternative to both Wayland and X11, for their operating system. 3 different display servers for linux, and both major GPU manufacturers are already having issues with one. This is just ridiculous. And anyways, just think of the users and distros, trying to find which one they should use.

As I said before, I was assuming Mir was exactly what it was planned (i.e. perfect-world scenario). I already stated that it was extremely hard to actually meet the requirements they wanted, let alone that Canonical is not exactly known for their amazing abilities at efficient coding. Just look at unity. Even GNOME 3 and KDE are faster than that! And GNOME 3 uses Javascript extensively (a language that I think we can all agree on its slowness). Unity is written in C, C++, and Vala, 3 languages that are quite fast (though using many languages together can slow down an application). Please tell me: Why is it that Unity is so much slower that GNOME or KDE, which have at least the same complexity, if not much more? (EDIT: Some people have said part of the cause of the slowness is because of Compiz and Nux. Nux, IIRC, is developed by Canonical too) Now look at the Ubuntu software center, and at Ubiquity, two other applications written by canonical. The USC took ~10 seconds to load, compared to most other applications loading nearly instantly. Of course, they are written in python, which, after programming in it for a rather long time (and having a lot of experience with other languages), I think I can say that it is not only a slow language, but also a rather badly designed one. Canonical did not, of course, make python, but I just used that to show you an example of their poor decisions. Enough hitting on Canonical, let’s assume that they are great coders now. How long do you think it would take to write a complete display server that is “extremely well-defined, well-tested, and portable”? Canonical is a rather small company, how do you think they will write an application (or library) that is “well-tested”? Or maybe we should ask, what defines “extremely well-defined” and “well-tested” (and “portable”)?

Lastly, let’s say that they were able to accomplish their goal. Why do they need a new display server in the first place? Why can’t they just use Wayland? There is a section on the wiki about this, which I tried to read, but it was quite vague. All that I could understand is that they wanted support for 3D input devices. So why don’t they just talk to the Wayland developers about this and maybe help them implement it if progress is not going fast enough? Or if they don’t want to have it in wayland, just fork it, don’t start writing your own. “In summary, we have not chosen Wayland/Weston as our basis for delivering a next-generation user experience as it does not fulfill our requirements completely”. Oh, come on. Wayland is open-source, you can change it if you need to, you know. Or if they don’t want the changes, you can just fork it. I know I’m repeating my last sentence, but this is just ridiculous.

So to summarize, I’m not that crazy about Mir :P

I know I said things rather bluntly, and I’m expecting that most of the reactions to this will be rather harsh, but I feel that it was important to write this. It’s not because I hate ubuntu that I write this, I really like the initiative, just not the execution (which is why I write these kinds of posts… maybe if enough people show their disapproval towards their methods, they might change their minds ^_^). Also, if you think that any of the claims I made were false, let me know, I’m not that closed-minded about it ;)